feat(lowcode): P2-b 动态 CRUD 内核 + 写工具 + seed 通道,修 pglite /dev/null 退出码 100
- sspf-lowcode 纯计算建表 DDL 生成 + 模型回写(任务 #12/#13) - 内核 lowcode_crud/check/ddl:真实事务执行、落库前三重校验、动态建表后回写 f_tables_data - MCP 暴露 data.record.insert/update/delete(任务 #15) - 开发期 --seed-lowcode-demo 通道:建表 + 写 dev/release 快照,prod 档开库前闸门拒绝 - 修 f_delete_mark 类型 bug(INTEGER 列误写 bool 导致 PG 报错) - 修 pglite 0.2.7 在 stdout=/dev/null 时 boot 阶段 kevent 失败 -> exit(100) 残留 pid: open_db 开库前若 fd1 是字符设备,dup2 到匿名普通临时文件 - 文档漂移清理(tools/mod.rs 工具数、form.rs/model.rs 注释)
This commit is contained in:
1 parent
343772be42
commit
bcbe46c92b
23 files changed
+11185
-26
No files matched your search
@@ -13,6 +13,10 @@
|
||||
//! 🔴 另加 [`bootstrap`] = **装配根**(唯一同时认识平台层与业务层的地方)。
|
||||
|
||||
pub mod bootstrap;
|
||||
pub mod lowcode_check;
|
||||
pub mod lowcode_crud;
|
||||
pub mod lowcode_ddl;
|
||||
pub mod lowcode_seed;
|
||||
pub mod mcp_adapter;
|
||||
pub mod modules;
|
||||
pub mod platform;
|
||||
|
||||
@@ -0,0 +1,501 @@
|
||||
//! lowcode_check —— 写库**之前**的业务校验层(P2-b)。
|
||||
//!
|
||||
//! ## 为什么要有这一层
|
||||
//!
|
||||
//! 底层「设计稿列 vs 真实库列」的比对([`crate::lowcode_crud`])只回答
|
||||
//! 「**能不能写**」(列在不在),不回答「**该不该写**」(值合不合法)。
|
||||
//!
|
||||
//! 基线平台在落库前有三道业务校验:
|
||||
//!
|
||||
//! | 校验 | 基线实现 | 本模块 |
|
||||
//! |---|---|---|
|
||||
//! | **业务主键** | `FormCheckUtils.checkBusinessKey()` | [`check_business_key`] |
|
||||
//! | **必填** | `FormCheckUtils.checkForm()` 里的 `config.isRequired()` | 已在 `sspf-lowcode` 层(`MISSING_REQUIRED`) |
|
||||
//! | **单行唯一** | `FormCheckUtils.checkForm()` 里的 `config.getUnique()` | [`check_unique_fields`] |
|
||||
//!
|
||||
//! ## 🔴 缺了会怎样
|
||||
//!
|
||||
//! 不做唯一性校验 ⇒ 库里能塞进两条「房间号相同」的记录 ⇒ 列表页看到重复数据,
|
||||
//! 而用户以为系统拦住了。基线平台是拦住的 ⇒ **行为不一致 = 迁移没对齐**。
|
||||
//!
|
||||
//! ## 🔴 三条对齐口径(都来自 Java 源码,不是经验)
|
||||
//!
|
||||
//! 1. **只有 `jnpfKey == "input"` 且 `unique == true` 的字段才查唯一**
|
||||
//! (Java `JnpfKeyConsts.COM_INPUT.equals(config.getJnpfKey())`)。
|
||||
//! 下拉/日期/数字控件标了 `unique` 也**不查** —— 查多了会拦住基线允许的写入。
|
||||
//! 2. **唯一性比对是「全表扫 + 排除自己」**,不是靠数据库 UNIQUE 约束。
|
||||
//! Java 是 `SELECT ... WHERE col = ? AND pk <> ?`,然后看 `count > 0`。
|
||||
//! 3. **业务主键是「组合唯一」**:清单里所有字段一起比;
|
||||
//! 任一字段为空 ⇒ 该字段用 `IS NULL` 参与比较(Java `setEachCondition`)。
|
||||
//!
|
||||
//! ## 🔴 逻辑删除的行算不算重复
|
||||
//!
|
||||
//! 基线平台:逻辑删除的行**仍然占着**这个唯一值 —— 它只在判重时补了
|
||||
//! `delete_mark IS NULL` 条件(`FormCheckUtils` 第 259–261 行),
|
||||
//! 所以逻辑删除的行**不参与**判重。
|
||||
//! ⇒ Rust 侧口径一致:查判重时带上 `delete_mark IS NULL`。
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
use sspf_lowcode::{check_identifier, lookup, FieldNode, FormSchema, ModelSchema};
|
||||
|
||||
use crate::platform::db::Db;
|
||||
use sspf_mcp::adapter::ToolError;
|
||||
|
||||
/// 🔴 唯一性冲突的错误。
|
||||
///
|
||||
/// 基线平台的文案是 `字段名 + MsgCode.EXIST103`(≈「已存在」),
|
||||
/// 这里给结构化的版本,AI 能据此自纠(改值 / 换 id)。
|
||||
pub fn unique_conflict(label: &str, column: &str, value: &Value) -> ToolError {
|
||||
let shown = match value {
|
||||
Value::String(s) => s.clone(),
|
||||
Value::Null => "NULL".to_string(),
|
||||
other => other.to_string(),
|
||||
};
|
||||
ToolError::new(
|
||||
"UNIQUE_CONSTRAINT_VIOLATED",
|
||||
format!("字段「{label}」({column}) 的值 {shown} 已经存在了"),
|
||||
)
|
||||
.field(column)
|
||||
.field("value")
|
||||
.hint(format!(
|
||||
"这个字段被设计成「单行唯一」;换一个值,或者先 data.query 看看哪条记录占着它"
|
||||
))
|
||||
.next(
|
||||
"data.query",
|
||||
serde_json::json!({ "enCode": "<功能编码>" }),
|
||||
"查哪条记录占着这个值",
|
||||
)
|
||||
}
|
||||
|
||||
/// 🔴 业务主键冲突的错误。
|
||||
pub fn business_key_conflict(tip: Option<&str>, columns: &[String]) -> ToolError {
|
||||
let cols = columns.join(" + ");
|
||||
let message = match tip {
|
||||
Some(t) if !t.trim().is_empty() => t.to_string(),
|
||||
_ => format!("业务主键({cols})已经存在了"),
|
||||
};
|
||||
ToolError::new("BUSINESS_KEY_VIOLATED", message)
|
||||
.field("businessKey")
|
||||
.hint(format!(
|
||||
"这个功能启用了业务主键({cols})—— 这几个字段的组合必须唯一;\
|
||||
换一个值,或先 data.query 查一下已有的组合"
|
||||
))
|
||||
.next(
|
||||
"data.query",
|
||||
serde_json::json!({ "enCode": "<功能编码>" }),
|
||||
"查已有的业务主键组合",
|
||||
)
|
||||
}
|
||||
|
||||
/// 🔴 单行唯一校验(对齐 `FormCheckUtils.checkForm()` 的 unique 分支)。
|
||||
///
|
||||
/// - 只查 `jnpfKey == "input"` **且** `unique == true` 的字段;
|
||||
/// - 比对范围:整张表(子表字段在**子表**里查,主表字段在**主表**里查);
|
||||
/// - 排除自己:`record_id` 存在时把该行排除(更新场景);
|
||||
/// - 逻辑删除的行不参与判重(`delete_mark IS NULL`)。
|
||||
///
|
||||
/// `record_id` 为 `None` ⇒ 新增场景(不排除任何行)。
|
||||
pub async fn check_unique_fields(
|
||||
db: &Db,
|
||||
form: &FormSchema,
|
||||
model: &ModelSchema,
|
||||
payload: &Value,
|
||||
record_id: Option<&str>,
|
||||
) -> Result<(), ToolError> {
|
||||
let fields = form.unique_fields();
|
||||
if fields.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let logical = form.logical_delete.unwrap_or(false);
|
||||
|
||||
for node in fields {
|
||||
// 这个字段属于哪张表?
|
||||
let (table_schema, column) = resolve_table_and_column(model, node).ok_or_else(|| {
|
||||
ToolError::new(
|
||||
"UNIQUE_CHECK_SKIPPED",
|
||||
format!(
|
||||
"字段「{}」({}) 标了唯一,但模型里找不到它对应的列 —— 跳过这一项的唯一校验",
|
||||
node.label, node.v_model
|
||||
),
|
||||
)
|
||||
.field(&node.v_model)
|
||||
.hint("先 form.describe 看这个字段到底属于哪张表;模型与表单对不上")
|
||||
})?;
|
||||
|
||||
let Some(raw) = lookup(payload, &node.v_model, &column) else {
|
||||
// 没给值 ⇒ Java 那边 `o` 为空 ⇒ 用 `IS NULL` 判重。
|
||||
// 但基线平台的 `unique` 语义是「这个值只能有一份」——
|
||||
// 没给值时判重没意义(多数列 NOT NULL,落库时自然会报)。
|
||||
// ⇒ 这里**跳过**:交给必填校验 / 数据库 NOT NULL 去管。
|
||||
continue;
|
||||
};
|
||||
|
||||
// Java `ObjectUtil.isEmpty(o) ? null : String.valueOf(o).trim()`
|
||||
let value = match &raw {
|
||||
Value::String(s) => {
|
||||
let t = s.trim();
|
||||
if t.is_empty() {
|
||||
continue;
|
||||
}
|
||||
Value::String(t.to_string())
|
||||
}
|
||||
Value::Null => continue,
|
||||
Value::Bool(b) => Value::String(b.to_string()),
|
||||
Value::Number(n) => Value::String(n.to_string()),
|
||||
_ => continue,
|
||||
};
|
||||
|
||||
let mut params: Vec<String> = Vec::new();
|
||||
let mut sql = format!(
|
||||
"SELECT 1 FROM {} WHERE {} = $1",
|
||||
table_schema.table, column
|
||||
);
|
||||
params.push(match &value {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
});
|
||||
|
||||
// 逻辑删除的行不参与判重(对齐 Java 的 `delete_mark IS NULL` 条件)。
|
||||
if logical {
|
||||
if let Some(dm) = delete_mark_column(table_schema) {
|
||||
sql.push_str(&format!(" AND {} IS NULL", dm));
|
||||
}
|
||||
}
|
||||
|
||||
// 更新场景:排除自己那行。
|
||||
if let Some(rid) = record_id {
|
||||
if let Some(pk) = primary_key_column(table_schema) {
|
||||
sql.push_str(&format!(" AND {} <> $2", pk));
|
||||
params.push(rid.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
sql.push_str(" LIMIT 1");
|
||||
|
||||
check_identifier("表名", &table_schema.table).map_err(ident_err)?;
|
||||
check_identifier("列名", &column).map_err(ident_err)?;
|
||||
|
||||
// 🔴 参数个数必须与 SQL 里的占位符**一一对应**。
|
||||
// 更新场景会多一个 `$2`(排除自己)⇒ 参数也要多一个。
|
||||
// 少传 ⇒ pglite 报 `statement takes 2 parameters, 1 given`。
|
||||
let refs: Vec<&(dyn pglite::ToSql + Sync)> = params
|
||||
.iter()
|
||||
.map(|s| s as &(dyn pglite::ToSql + Sync))
|
||||
.collect();
|
||||
let rows = db
|
||||
.query_json_params(&sql, &refs)
|
||||
.await
|
||||
.map_err(|e| {
|
||||
ToolError::new("DB_ERROR", format!("唯一性校验查库失败: {e}"))
|
||||
.hint("先 schema.table.describe 看这张表的结构")
|
||||
.retryable()
|
||||
})?;
|
||||
|
||||
if !rows.is_empty() {
|
||||
return Err(unique_conflict(&node.label, &column, &value));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 🔴 业务主键校验(对齐 `FormCheckUtils.checkBusinessKey()`)。
|
||||
///
|
||||
/// - 只在 `useBusinessKey == true` 且 `businessKeyList` 非空时生效;
|
||||
/// - 清单里所有字段**一起**比(组合唯一);
|
||||
/// - 任一字段没给值 ⇒ 该字段用 `IS NULL` 参与比较;
|
||||
/// - 更新场景排除自己;
|
||||
/// - 逻辑删除的行不参与判重。
|
||||
pub async fn check_business_key(
|
||||
db: &Db,
|
||||
form: &FormSchema,
|
||||
model: &ModelSchema,
|
||||
payload: &Value,
|
||||
record_id: Option<&str>,
|
||||
) -> Result<(), ToolError> {
|
||||
let Some(nodes) = form.business_key_fields() else {
|
||||
return Ok(());
|
||||
};
|
||||
let Some(main) = model.main_table() else {
|
||||
return Ok(());
|
||||
};
|
||||
let logical = form.logical_delete.unwrap_or(false);
|
||||
|
||||
// 把每个业务主键字段解析成「物理列 + 值」
|
||||
let mut cols: Vec<String> = Vec::new();
|
||||
let mut values: Vec<Option<String>> = Vec::new();
|
||||
for node in &nodes {
|
||||
let Some((tbl, col)) = resolve_table_and_column(model, node) else {
|
||||
// 清单里的字段在模型里找不到 ⇒ 没法校验。
|
||||
// 静默跳过会放过重复数据 ⇒ 明确报错,让 AI 知道设计稿有问题。
|
||||
return Err(ToolError::new(
|
||||
"BUSINESS_KEY_CHECK_FAILED",
|
||||
format!(
|
||||
"业务主键清单里的字段「{}」({}) 在模型里找不到对应的列 —— 无法校验",
|
||||
node.label, node.v_model
|
||||
),
|
||||
)
|
||||
.field(&node.v_model)
|
||||
.hint("先 form.describe 看这个功能的字段与模型是否对得上"));
|
||||
};
|
||||
if !tbl.table.eq_ignore_ascii_case(&main.table) {
|
||||
// 业务主键只在**主表**上判重(Java `checkBusinessKey` 用 mainTable)。
|
||||
continue;
|
||||
}
|
||||
let v = lookup(payload, &node.v_model, &col)
|
||||
.and_then(|v| match v {
|
||||
Value::String(s) => {
|
||||
let t = s.trim();
|
||||
if t.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(t.to_string())
|
||||
}
|
||||
}
|
||||
Value::Null => None,
|
||||
Value::Bool(b) => Some(b.to_string()),
|
||||
Value::Number(n) => Some(n.to_string()),
|
||||
_ => None,
|
||||
});
|
||||
cols.push(col);
|
||||
values.push(v);
|
||||
}
|
||||
if cols.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
check_identifier("表名", &main.table).map_err(ident_err)?;
|
||||
|
||||
// WHERE 条件:每个业务主键列 = ? (值为空则 IS NULL)
|
||||
let mut where_parts: Vec<String> = Vec::new();
|
||||
let mut params: Vec<String> = Vec::new();
|
||||
for (i, (col, val)) in cols.iter().zip(values.iter()).enumerate() {
|
||||
check_identifier("列名", col).map_err(ident_err)?;
|
||||
match val {
|
||||
Some(v) => {
|
||||
params.push(v.clone());
|
||||
where_parts.push(format!("{} = ${}", col, params.len()));
|
||||
}
|
||||
None => {
|
||||
where_parts.push(format!("{} IS NULL", col));
|
||||
}
|
||||
}
|
||||
let _ = i;
|
||||
}
|
||||
|
||||
let mut sql = format!("SELECT 1 FROM {} WHERE {}", main.table, where_parts.join(" AND "));
|
||||
|
||||
if logical {
|
||||
if let Some(dm) = delete_mark_column(main) {
|
||||
sql.push_str(&format!(" AND {} IS NULL", dm));
|
||||
}
|
||||
}
|
||||
if let Some(rid) = record_id {
|
||||
if let Some(pk) = primary_key_column(main) {
|
||||
params.push(rid.to_string());
|
||||
sql.push_str(&format!(" AND {} <> ${}", pk, params.len()));
|
||||
}
|
||||
}
|
||||
sql.push_str(" LIMIT 1");
|
||||
|
||||
let refs: Vec<&(dyn pglite::ToSql + Sync)> = params
|
||||
.iter()
|
||||
.map(|s| s as &(dyn pglite::ToSql + Sync))
|
||||
.collect();
|
||||
let rows = db
|
||||
.query_json_params(&sql, &refs)
|
||||
.await
|
||||
.map_err(|e| {
|
||||
ToolError::new("DB_ERROR", format!("业务主键校验查库失败: {e}"))
|
||||
.hint("先 schema.table.describe 看这张表的结构")
|
||||
.retryable()
|
||||
})?;
|
||||
|
||||
if !rows.is_empty() {
|
||||
return Err(business_key_conflict(
|
||||
form.business_key_tip.as_deref(),
|
||||
&cols,
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 🔴 标识符非法时的错误转换。
|
||||
fn ident_err(e: sspf_lowcode::SqlError) -> ToolError {
|
||||
ToolError::new(e.code(), e.message()).hint("表名/列名只能含字母、数字、下划线")
|
||||
}
|
||||
|
||||
/// 🔴 找字段属于哪张表 + 它对应的物理列名。
|
||||
///
|
||||
/// 主表字段 → 主表;子表字段 → 子表(靠 `relationTable`)。
|
||||
fn resolve_table_and_column<'a>(
|
||||
model: &'a ModelSchema,
|
||||
node: &FieldNode,
|
||||
) -> Option<(&'a sspf_lowcode::TableSchema, String)> {
|
||||
// 子表字段:靠 `relationTable`(`tableName` 对子表字段不可信 —— 见 form.rs 注释)
|
||||
if let Some(rel) = &node.relation_table {
|
||||
if let Some(t) = model.table(rel) {
|
||||
if let Some(col) = column_for(t, node) {
|
||||
return Some((t, col));
|
||||
}
|
||||
}
|
||||
}
|
||||
// 主表字段:靠 `tableName`;退回到主表
|
||||
if let Some(tn) = &node.table_name {
|
||||
if let Some(t) = model.table(tn) {
|
||||
if let Some(col) = column_for(t, node) {
|
||||
return Some((t, col));
|
||||
}
|
||||
}
|
||||
}
|
||||
let main = model.main_table()?;
|
||||
let col = column_for(main, node)?;
|
||||
Some((main, col))
|
||||
}
|
||||
|
||||
/// 🔴 在一张表的列定义里找这个字段的物理列名。
|
||||
fn column_for(table: &sspf_lowcode::TableSchema, node: &FieldNode) -> Option<String> {
|
||||
// 先按 `__vModel__` 精确匹配
|
||||
if let Some(c) = table.column_by_field(&node.v_model) {
|
||||
if let Some(col) = c.resolved_column() {
|
||||
return Some(col);
|
||||
}
|
||||
}
|
||||
// 再按「剥前缀 + 转小写」推导
|
||||
sspf_lowcode::v_model_to_column(&node.v_model)
|
||||
}
|
||||
|
||||
/// 🔴 主键列(排除租户列 —— Java `checkBusinessKey` 的口径)。
|
||||
fn primary_key_column(table: &sspf_lowcode::TableSchema) -> Option<String> {
|
||||
table
|
||||
.primary_keys()
|
||||
.into_iter()
|
||||
.find(|c| !c.contains("f_tenant_id"))
|
||||
}
|
||||
|
||||
/// 🔴 删除标记列(逻辑删除时用来排除已删行)。
|
||||
fn delete_mark_column(table: &sspf_lowcode::TableSchema) -> Option<String> {
|
||||
table
|
||||
.fields
|
||||
.iter()
|
||||
.find(|c| {
|
||||
let f = c.field.to_lowercase();
|
||||
f.contains("f_delete_mark") || f == "delete_mark"
|
||||
})
|
||||
.and_then(|c| c.resolved_column())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
const FORM: &str = r#"{
|
||||
"logicalDelete": true,
|
||||
"useBusinessKey": true,
|
||||
"businessKeyList": ["F_Code"],
|
||||
"businessKeyTip": "业务编码已存在",
|
||||
"fields": [
|
||||
{
|
||||
"__config__": {
|
||||
"jnpfKey": "input", "layout": "colFormItem", "label": "房间号",
|
||||
"tableName": "biz_main", "required": true, "unique": true
|
||||
},
|
||||
"__vModel__": "F_Room"
|
||||
},
|
||||
{
|
||||
"__config__": {
|
||||
"jnpfKey": "input", "layout": "colFormItem", "label": "业务编码",
|
||||
"tableName": "biz_main", "required": false
|
||||
},
|
||||
"__vModel__": "F_Code"
|
||||
},
|
||||
{
|
||||
"__config__": {
|
||||
"jnpfKey": "inputNumber", "layout": "colFormItem", "label": "数量",
|
||||
"tableName": "biz_main", "unique": true
|
||||
},
|
||||
"__vModel__": "F_Qty"
|
||||
}
|
||||
]
|
||||
}"#;
|
||||
|
||||
const MODEL: &str = r#"[
|
||||
{
|
||||
"table": "biz_main", "tableName": "主表", "typeId": "1",
|
||||
"fields": [
|
||||
{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar",
|
||||
"primaryKey": 1, "allowNull": false },
|
||||
{ "field": "F_Tenant_Id", "fieldName": "租户", "dataType": "varchar",
|
||||
"primaryKey": 1, "allowNull": false },
|
||||
{ "field": "F_Room", "fieldName": "房间号", "dataType": "varchar" },
|
||||
{ "field": "F_Code", "fieldName": "业务编码", "dataType": "varchar" },
|
||||
{ "field": "F_Qty", "fieldName": "数量", "dataType": "int4" },
|
||||
{ "field": "F_Delete_Mark", "fieldName": "删除标记", "dataType": "int4" }
|
||||
]
|
||||
}
|
||||
]"#;
|
||||
|
||||
fn form() -> FormSchema {
|
||||
FormSchema::parse(&json!({
|
||||
"fields": serde_json::from_str::<Value>(FORM).unwrap()["fields"].clone(),
|
||||
"logicalDelete": true,
|
||||
"useBusinessKey": true,
|
||||
"businessKeyList": ["F_Code"],
|
||||
"businessKeyTip": "业务编码已存在",
|
||||
}))
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn model() -> ModelSchema {
|
||||
ModelSchema::parse(&serde_json::from_str::<Value>(MODEL).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
/// 🔴 只有 `input` + `unique` 才参与判重 —— 数字控件标了 unique 也不查。
|
||||
#[test]
|
||||
fn only_input_with_unique_is_checked() {
|
||||
let f = form();
|
||||
let uniq = f.unique_fields();
|
||||
assert_eq!(uniq.len(), 1, "应该只有 F_Room 一个字段参与唯一校验");
|
||||
assert_eq!(uniq[0].v_model, "F_Room");
|
||||
}
|
||||
|
||||
/// 🔴 业务主键清单能被解析成字段。
|
||||
#[test]
|
||||
fn business_key_fields_are_resolved() {
|
||||
let f = form();
|
||||
let bk = f.business_key_fields().expect("应该启用业务主键");
|
||||
assert_eq!(bk.len(), 1);
|
||||
assert_eq!(bk[0].v_model, "F_Code");
|
||||
}
|
||||
|
||||
/// 🔴 没启用业务主键 ⇒ 不校验。
|
||||
#[test]
|
||||
fn business_key_disabled_returns_none() {
|
||||
let f = FormSchema::parse(&json!({
|
||||
"fields": serde_json::from_str::<Value>(FORM).unwrap()["fields"].clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
assert!(f.business_key_fields().is_none());
|
||||
}
|
||||
|
||||
/// 🔴 主键列要排除租户列。
|
||||
#[test]
|
||||
fn primary_key_excludes_tenant() {
|
||||
let m = model();
|
||||
let main = m.main_table().unwrap();
|
||||
assert_eq!(
|
||||
primary_key_column(main).as_deref(),
|
||||
Some("f_id"),
|
||||
"租户列也是 primaryKey=1,但不能被当成主键"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 删除标记列能被认出来。
|
||||
#[test]
|
||||
fn delete_mark_column_is_found() {
|
||||
let m = model();
|
||||
let main = m.main_table().unwrap();
|
||||
assert_eq!(delete_mark_column(main).as_deref(), Some("f_delete_mark"));
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,430 @@
|
||||
//! lowcode_ddl —— 内核侧的**动态建表执行层**(P2-b 的最后一块)。
|
||||
//!
|
||||
//! ## 分工(与 [`crate::lowcode_crud`] 同款)
|
||||
//!
|
||||
//! | 层 | 位置 | 干什么 |
|
||||
//! |---|---|---|
|
||||
//! | **DDL 生成** | `sspf-lowcode::ddl`(纯计算,AR7) | 出 `CREATE TABLE` 文本 + 回写后的模型 |
|
||||
//! | **执行** | 本文件(内核) | 连库、跑 DDL、回写 `f_tables_data` |
|
||||
//!
|
||||
//! ## 🔴 三步闭环(缺一不可)
|
||||
//!
|
||||
//! ```text
|
||||
//! 1. plan_create() → CREATE TABLE 文本(主表在前,子表随后)
|
||||
//! 2. 执行 DDL → 真实库里有表了
|
||||
//! 3. rewrite_model() → 把真实表结构回写进 f_tables_data
|
||||
//! ```
|
||||
//!
|
||||
//! ## 🔴 第 3 步为什么**不是可选的**
|
||||
//!
|
||||
//! 基线平台 `VisualDevTableCre.tableList()` 建完表后会用**建表清单**重新组装
|
||||
//! `TableModel` 再写回 `f_tables_data`:
|
||||
//!
|
||||
//! ```java
|
||||
//! this.tableModel(tableModelList, datableList, tableName, table, true, tableField, relationField);
|
||||
//! ...
|
||||
//! entity.setVisualTables(JsonUtil.getObjectToString(tableModelList));
|
||||
//! ```
|
||||
//!
|
||||
//! ⇒ 建表后的模型**含平台追加的系统列**(`f_tenant_id` / `f_delete_mark` …)。
|
||||
//!
|
||||
//! 不回写的后果(本项目已真实踩到):
|
||||
//!
|
||||
//! | 现象 | 根因 |
|
||||
//! |---|---|
|
||||
//! | 逻辑删除报 `LOGICAL_DELETE_UNSUPPORTED` | CRUD 层在**模型**里找 `f_delete_mark`,找不到 |
|
||||
//! | 「设计稿 vs 真实库」列比对永远对不上 | 模型少列、真实库多列 |
|
||||
//! | `f_tenant_id` 不被写 | 租户列在模型里缺失 |
|
||||
//!
|
||||
//! ## 🔴 幂等
|
||||
//!
|
||||
//! 基线平台 `DbTableServiceImpl.createTable()` 会先检查表是否已存在,
|
||||
//! 存在则直接返回(不重复建)。本模块同理:
|
||||
//!
|
||||
//! - 表已存在 ⇒ **不报错**,跳过 DDL,但**仍然回写模型**
|
||||
//! (回写是幂等的,且让「设计稿落后于真实库」自动修复)。
|
||||
//! - 表已存在但**列结构不同** ⇒ 报 `TABLE_ALREADY_EXISTS_DIFFERENT`,
|
||||
//! 明确告诉调用方「不是同一次建表的结果」,让人去核对而不是硬改。
|
||||
//!
|
||||
//! ## 🔴 只在开发期可用
|
||||
//!
|
||||
//! 建表是**破坏性**操作(会改真实库结构)。本模块提供 `Profile::Dev` 闸门,
|
||||
//! 生产档直接拒绝 —— 见 [`create_tables`].
|
||||
|
||||
use serde_json::{json, Value};
|
||||
|
||||
use sspf_lowcode::{
|
||||
plan_create, rewrite_model, CreatePlan, DdlError, DdlOptions, FormSchema, ModelSchema,
|
||||
};
|
||||
use sspf_mcp::adapter::ToolError;
|
||||
|
||||
use crate::platform::db::Db;
|
||||
|
||||
/// 建表的结果。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct CreateTablesOutcome {
|
||||
/// 建出来的表(主表在前)。
|
||||
pub tables: Vec<String>,
|
||||
/// 哪些表是**已存在**因而跳过的。
|
||||
pub skipped: Vec<String>,
|
||||
/// 回写后的模型(`f_tables_data` 的新值)。
|
||||
pub model: Value,
|
||||
/// 诊断信息。
|
||||
pub notes: Vec<String>,
|
||||
/// 实际执行的 DDL(dry-run 时给调用方看)。
|
||||
pub ddl: Vec<String>,
|
||||
/// 是否只是演练(没建表、没回写)。
|
||||
pub dry_run: bool,
|
||||
}
|
||||
|
||||
impl CreateTablesOutcome {
|
||||
/// 一共几张表。
|
||||
pub fn table_count(&self) -> usize {
|
||||
self.tables.len()
|
||||
}
|
||||
}
|
||||
|
||||
/// 🔴 把 DDL 错误转成结构化工具错误。
|
||||
pub fn ddl_err(e: DdlError) -> ToolError {
|
||||
let mut t = ToolError::new(e.code(), e.message());
|
||||
match &e {
|
||||
DdlError::NoMainTable => {
|
||||
t = t.hint("这个功能定义里没有主表(typeId=1)—— 设计稿不完整");
|
||||
}
|
||||
DdlError::IllegalIdentifier { kind, value } => {
|
||||
t = t
|
||||
.field(*kind)
|
||||
.hint(format!(
|
||||
"{kind}「{value}」含非法字符;表名/列名只允许字母、数字、下划线,且不能以数字开头"
|
||||
))
|
||||
.next("form.describe", json!({ "enCode": "<功能编码>" }), "看设计稿里的表名");
|
||||
}
|
||||
DdlError::DuplicateColumn { table, column } => {
|
||||
t = t
|
||||
.field(column)
|
||||
.hint(format!(
|
||||
"表 {table} 里两列推出同一个物理列名 {column};检查模型里是不是有同义字段"
|
||||
));
|
||||
}
|
||||
DdlError::UnsupportedType {
|
||||
table,
|
||||
column,
|
||||
data_type,
|
||||
} => {
|
||||
t = t
|
||||
.field(column)
|
||||
.hint(format!(
|
||||
"表 {table} 的列 {column} 类型「{data_type}」还没支持;\
|
||||
改这个字段的类型,或在 sspf-lowcode 的 map_type() 里补上"
|
||||
));
|
||||
}
|
||||
DdlError::InvalidLength {
|
||||
table,
|
||||
column,
|
||||
length,
|
||||
} => {
|
||||
t = t
|
||||
.field(column)
|
||||
.hint(format!(
|
||||
"表 {table} 的列 {column} 长度「{length}」不合法;\
|
||||
varchar 填数字,decimal 填「精度,标度」如 18,2"
|
||||
));
|
||||
}
|
||||
DdlError::NoPrimaryKey(table) => {
|
||||
t = t
|
||||
.hint(format!(
|
||||
"表 {table} 的模型里没有 primaryKey=1 的列 —— 建不出主键,先在设计稿里标主键"
|
||||
));
|
||||
}
|
||||
}
|
||||
t
|
||||
}
|
||||
|
||||
/// 🔴 表是否已存在。
|
||||
pub async fn table_exists(db: &Db, table: &str) -> Result<bool, ToolError> {
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT 1 AS \"x\" FROM information_schema.tables \
|
||||
WHERE table_name = $1 LIMIT 1",
|
||||
&[&table.to_string()],
|
||||
)
|
||||
.await
|
||||
.map_err(db_err)?;
|
||||
Ok(!rows.is_empty())
|
||||
}
|
||||
|
||||
/// 🔴 真实库里某张表的列(按序)。
|
||||
pub async fn real_columns(db: &Db, table: &str) -> Result<Vec<String>, ToolError> {
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT column_name AS \"name\" FROM information_schema.columns \
|
||||
WHERE table_name = $1 ORDER BY ordinal_position",
|
||||
&[&table.to_string()],
|
||||
)
|
||||
.await
|
||||
.map_err(db_err)?;
|
||||
Ok(rows
|
||||
.iter()
|
||||
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// 🔴 执行一次动态建表(**幂等**)。
|
||||
///
|
||||
/// ## 参数
|
||||
///
|
||||
/// - `db`:真实库连接;
|
||||
/// - `model`:**建表前**的模型(`f_tables_data`);
|
||||
/// - `form`:表单定义(决定 `logicalDelete` / `primaryKeyPolicy`);
|
||||
/// - `dry_run`:只生成 DDL 与回写后的模型,**不建表、不回写**。
|
||||
///
|
||||
/// ## 🔴 幂等语义
|
||||
///
|
||||
/// 表已存在 ⇒ 跳过 DDL,但**仍回写模型**(回写是幂等的)。
|
||||
/// 列结构不一致 ⇒ 报 `TABLE_EXISTS_DIFFERENT`,让人去核对。
|
||||
pub async fn create_tables(
|
||||
db: &Db,
|
||||
model: &ModelSchema,
|
||||
form: &FormSchema,
|
||||
dry_run: bool,
|
||||
) -> Result<CreateTablesOutcome, ToolError> {
|
||||
// 🔴 建表选项来自**表单**(基线平台同款:`VisualTableModel` 从 `FormDataModel` 取)。
|
||||
let options = DdlOptions {
|
||||
logical_delete: form.logical_delete.unwrap_or(false),
|
||||
with_comments: false,
|
||||
primary_key_policy: form.primary_key_policy.unwrap_or(1),
|
||||
};
|
||||
|
||||
let plan = plan_create(model, &options).map_err(ddl_err)?;
|
||||
let ddl = plan.render();
|
||||
|
||||
// ---- 回写后的模型(纯计算,先算好;dry-run 也要给)----
|
||||
let rewritten = rewrite_model(model, &plan);
|
||||
|
||||
let mut tables = Vec::new();
|
||||
let mut skipped = Vec::new();
|
||||
let mut notes = Vec::new();
|
||||
|
||||
if dry_run {
|
||||
for t in plan.all() {
|
||||
tables.push(t.table.clone());
|
||||
}
|
||||
return Ok(CreateTablesOutcome {
|
||||
tables,
|
||||
skipped,
|
||||
model: rewritten,
|
||||
notes: vec!["dry-run:没有建表,也没有回写模型".to_string()],
|
||||
ddl,
|
||||
dry_run: true,
|
||||
});
|
||||
}
|
||||
|
||||
// ---- 逐表执行(主表在前,子表随后)----
|
||||
for t in plan.all() {
|
||||
if table_exists(db, &t.table).await? {
|
||||
// 🔴 已存在 ⇒ 跳过 DDL,但**核对列**。
|
||||
let actual = real_columns(db, &t.table).await?;
|
||||
let expected = t.column_names();
|
||||
if actual != expected {
|
||||
return Err(table_exists_different(&t.table, &expected, &actual));
|
||||
}
|
||||
skipped.push(t.table.clone());
|
||||
notes.push(format!(
|
||||
"表 {} 已存在且列结构一致 —— 跳过建表(幂等)",
|
||||
t.table
|
||||
));
|
||||
continue;
|
||||
}
|
||||
|
||||
let sql = t.render();
|
||||
db.exec(&sql)
|
||||
.await
|
||||
.map_err(|e| create_failed(&t.table, &e.to_string(), &sql))?;
|
||||
tables.push(t.table.clone());
|
||||
}
|
||||
|
||||
Ok(CreateTablesOutcome {
|
||||
tables,
|
||||
skipped,
|
||||
model: rewritten,
|
||||
notes,
|
||||
ddl,
|
||||
dry_run: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// 🔴 表已存在但列结构不一致。
|
||||
fn table_exists_different(table: &str, expected: &[String], actual: &[String]) -> ToolError {
|
||||
let missing: Vec<&str> = expected
|
||||
.iter()
|
||||
.filter(|c| !actual.contains(c))
|
||||
.map(|s| s.as_str())
|
||||
.collect();
|
||||
let extra: Vec<&str> = actual
|
||||
.iter()
|
||||
.filter(|c| !expected.contains(c))
|
||||
.map(|s| s.as_str())
|
||||
.collect();
|
||||
|
||||
let mut msg = format!("表 {table} 已存在,但列结构和设计稿对不上");
|
||||
if !missing.is_empty() {
|
||||
msg.push_str(&format!(";设计稿声明但库里没有:{}", missing.join(", ")));
|
||||
}
|
||||
if !extra.is_empty() {
|
||||
msg.push_str(&format!(";库里有但设计稿没声明:{}", extra.join(", ")));
|
||||
}
|
||||
|
||||
ToolError::new("TABLE_EXISTS_DIFFERENT", msg)
|
||||
.field("table")
|
||||
.hint(
|
||||
"这张表不是当前设计稿建出来的(可能是手写的、或改过设计稿没重建表)。\
|
||||
改设计稿请先重建表,或手动对齐库里的列 —— 别让工具替你猜",
|
||||
)
|
||||
.next(
|
||||
"schema.table.describe",
|
||||
json!({ "table": table }),
|
||||
"看这张表现在到底有哪些列",
|
||||
)
|
||||
}
|
||||
|
||||
/// 🔴 建表失败。
|
||||
fn create_failed(table: &str, err: &str, sql: &str) -> ToolError {
|
||||
ToolError::new("CREATE_TABLE_FAILED", format!("建表 {table} 失败:{err}"))
|
||||
.field("table")
|
||||
.hint("看下面的 DDL 定位问题;最常见是标识符非法或类型不匹配")
|
||||
.hint(format!("执行的 DDL:{}", sql))
|
||||
.next(
|
||||
"form.describe",
|
||||
json!({ "enCode": "<功能编码>" }),
|
||||
"核对设计稿里的表名与列",
|
||||
)
|
||||
}
|
||||
|
||||
/// 🔴 DB 错误转工具错误。
|
||||
fn db_err(e: pglite::Error) -> ToolError {
|
||||
ToolError::new("DB_ERROR", format!("数据库错误:{e}"))
|
||||
.hint("先确认数据库连接正常;这个错误通常来自 SQL 或连接配置")
|
||||
}
|
||||
|
||||
/// 🔴 把回写后的模型写回 `base_visual_dev.f_tables_data`。
|
||||
///
|
||||
/// ## 🔴 为什么**只**写 `f_tables_data`
|
||||
///
|
||||
/// 基线平台 `VisualdevServiceImpl.createTable()` 建表后写的是
|
||||
/// `entity.setVisualTables(...)` —— 也就是 `f_tables_data` 一列。
|
||||
/// `f_column_data`(列表列)与 `f_form_data`(控件树)由前端另行维护,
|
||||
/// 建表不碰它们。
|
||||
pub async fn write_back_model(
|
||||
db: &Db,
|
||||
visualdev_id: &str,
|
||||
model_json: &Value,
|
||||
) -> Result<(), ToolError> {
|
||||
let text = serde_json::to_string(model_json).map_err(|e| {
|
||||
ToolError::new("MODEL_SERIALIZE_FAILED", format!("模型序列化失败:{e}"))
|
||||
})?;
|
||||
|
||||
// 🔴 先确认记录存在 —— `exec_params` 不返回影响行数
|
||||
// (pglite 0.2.7 没有这个能力),所以只能先查再写。
|
||||
let exists = db
|
||||
.query_json_params(
|
||||
"SELECT 1 AS \"x\" FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
|
||||
&[&visualdev_id.to_string()],
|
||||
)
|
||||
.await
|
||||
.map_err(db_err)?;
|
||||
if exists.is_empty() {
|
||||
return Err(ToolError::new(
|
||||
"FORM_NOT_FOUND",
|
||||
format!("低代码功能不存在:{visualdev_id}"),
|
||||
)
|
||||
.field("id")
|
||||
.hint("base_visual_dev 里没有这条记录")
|
||||
.next("form.list", json!({}), "列出全部功能"));
|
||||
}
|
||||
|
||||
db.exec_params(
|
||||
"UPDATE base_visual_dev SET f_tables_data = $1 WHERE f_id = $2",
|
||||
&[&text, &visualdev_id.to_string()],
|
||||
)
|
||||
.await
|
||||
.map_err(db_err)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 🔴 建表 + 回写的完整闭环。
|
||||
///
|
||||
/// 这是 MCP `schema.table.create` 工具背后的实现:
|
||||
/// 建表 → 回写 `f_tables_data` → 返回可用的模型。
|
||||
pub async fn create_and_sync(
|
||||
db: &Db,
|
||||
visualdev_id: &str,
|
||||
model: &ModelSchema,
|
||||
form: &FormSchema,
|
||||
dry_run: bool,
|
||||
) -> Result<CreateTablesOutcome, ToolError> {
|
||||
let outcome = create_tables(db, model, form, dry_run).await?;
|
||||
|
||||
if !dry_run {
|
||||
write_back_model(db, visualdev_id, &outcome.model).await?;
|
||||
}
|
||||
|
||||
Ok(outcome)
|
||||
}
|
||||
|
||||
/// 🔴 一张表的 DDL 预览(只给主表,供 `schema.table.describe` 之类的诊断用)。
|
||||
pub fn preview_ddl(model: &ModelSchema, form: &FormSchema) -> Result<Vec<String>, ToolError> {
|
||||
let options = DdlOptions {
|
||||
logical_delete: form.logical_delete.unwrap_or(false),
|
||||
with_comments: false,
|
||||
primary_key_policy: form.primary_key_policy.unwrap_or(1),
|
||||
};
|
||||
let plan: CreatePlan = plan_create(model, &options).map_err(ddl_err)?;
|
||||
Ok(plan.render())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn model() -> ModelSchema {
|
||||
ModelSchema::from_str(
|
||||
r#"[{ "table": "t_main", "tableName": "主表", "typeId": "1", "fields": [
|
||||
{ "field": "F_Id", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 },
|
||||
{ "field": "F_Room", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }
|
||||
]}]"#,
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn form() -> FormSchema {
|
||||
FormSchema::from_str(
|
||||
r#"{ "formRef": "formRef", "formModel": "formData",
|
||||
"primaryKeyPolicy": 1, "logicalDelete": false, "fields": [] }"#,
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
/// DDL 预览应产出 `CREATE TABLE`。
|
||||
#[test]
|
||||
fn preview_ddl_produces_create_table() {
|
||||
let ddl = preview_ddl(&model(), &form()).unwrap();
|
||||
assert_eq!(ddl.len(), 1);
|
||||
assert!(ddl[0].starts_with("CREATE TABLE t_main"), "{}", ddl[0]);
|
||||
assert!(ddl[0].contains("PRIMARY KEY (f_id, f_tenant_id)"), "{}", ddl[0]);
|
||||
}
|
||||
|
||||
/// 🔴 DDL 错误要转成有指导性的工具错误。
|
||||
#[test]
|
||||
fn ddl_error_becomes_actionable_tool_error() {
|
||||
let bad = ModelSchema::from_str(
|
||||
r#"[{ "table": "bad; DROP TABLE x", "typeId": "1", "fields": [
|
||||
{ "field": "F_Id", "dataType": "varchar", "primaryKey": 1 }
|
||||
]}]"#,
|
||||
)
|
||||
.unwrap();
|
||||
let err = preview_ddl(&bad, &form()).unwrap_err();
|
||||
assert_eq!(err.code, "ILLEGAL_IDENTIFIER");
|
||||
assert!(!err.hints.is_empty(), "非法标识符必须给出修复指引");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,503 @@
|
||||
//! lowcode_seed —— **开发期**低代码示例数据种子(CLI `--seed-lowcode-demo`)。
|
||||
//!
|
||||
//! ## 它干什么
|
||||
//!
|
||||
//! 往库里灌**一份可用的低代码功能**,让 P2-b 的动态 CRUD 能被端到端验证:
|
||||
//!
|
||||
//! 1. `base_visual_dev` 一行(`f_form_data` = 官方 fixture 的控件树,
|
||||
//! `f_tables_data` = 官方 fixture 的表结构);
|
||||
//! 2. 按设计稿**真的建出物理表**(`test_receivable` / `test_details`);
|
||||
//! 3. 建表后**回写** `f_tables_data`(含平台追加的系统列)—— 与基线平台同款;
|
||||
//! 4. `base_visual_release` 一行(发布快照,三段 JSON 与 dev 一致)。
|
||||
//!
|
||||
//! ## 🔴 为什么要有这条通道
|
||||
//!
|
||||
//! P2-b 的动态 CRUD 需要「**一个真的低代码功能**」才能验证;而手点界面造一个
|
||||
//! 功能 = 慢且不可复现 ⇒ 提供一条**命令行、可重复**的通道:
|
||||
//!
|
||||
//! ```text
|
||||
//! ssw-platform --seed-lowcode-demo # 建表 + 灌功能定义
|
||||
//! ssw-platform --seed-lowcode-demo --dry-run # 只看要做什么,不碰库
|
||||
//! ```
|
||||
//!
|
||||
//! ## 🔴 数据来源是**官方初始化数据**
|
||||
//!
|
||||
//! fixture 与 `crates/sspf-lowcode/tests/fixtures/` 同源(基线平台初始化 SQL 里的
|
||||
//! 「应收费用」功能)⇒ 种出来的库**就是基线平台的低代码功能在 SSPF 里的样子**
|
||||
//! —— 验证才有意义(自己编的数据只能证明「自己和自己通」)。
|
||||
//!
|
||||
//! ## 🔴 只在开发档可用
|
||||
//!
|
||||
//! 它会**改真实库结构**(建表)⇒ 生产档直接拒绝(见 [`seed_gate`])。
|
||||
//!
|
||||
//! ## 🔴 幂等
|
||||
//!
|
||||
//! 固定 id + 「先查存在性再写」⇒ 重复跑不会撞复合主键,也不会留下重复行。
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
use sspf_lowcode::{FormSchema, ModelSchema};
|
||||
use sspf_mcp::adapter::ToolError;
|
||||
|
||||
use crate::lowcode_crud::now_iso;
|
||||
use crate::lowcode_ddl;
|
||||
use crate::platform::config::Profile;
|
||||
use crate::platform::db::{pglite, Db};
|
||||
use crate::platform::system::MAIN_SYSTEM_ID;
|
||||
|
||||
/// 示例功能在 `base_visual_dev` 里的**固定 id**。
|
||||
///
|
||||
/// 🔴 用**固定 id** 而不是新生成 UUID —— 固定 id 让种子幂等:
|
||||
/// 重复跑 `--seed-lowcode-demo` 是「更新同一条」而不是「插一堆重复的」。
|
||||
pub const DEMO_ID: &str = "lowcode-demo-receivable";
|
||||
|
||||
/// 示例功能的编码(`f_en_code`)—— AI 调 `data.record.insert` 时用它定位。
|
||||
///
|
||||
/// 🔴 与 MCP 工具文档里的示例(`crates/sspf-mcp/src/tools/lowcode.rs`)**逐字一致**
|
||||
/// ⇒ 文档里的示例直接可跑。
|
||||
pub const DEMO_EN_CODE: &str = "receivableDemo";
|
||||
|
||||
/// 示例功能的显示名。
|
||||
pub const DEMO_FULL_NAME: &str = "应收费用(低代码示例)";
|
||||
|
||||
/// 表单 fixture(相对项目根)。
|
||||
const FORM_FIXTURE: &str = "crates/sspf-lowcode/tests/fixtures/sample_form.json";
|
||||
|
||||
/// 模型 fixture(相对项目根)。
|
||||
const MODEL_FIXTURE: &str = "crates/sspf-lowcode/tests/fixtures/sample_model.json";
|
||||
|
||||
/// 单租户口径下的租户值(与 `lowcode_crud::DEFAULT_TENANT_ID` 同源)。
|
||||
const TENANT_ID: &str = "0";
|
||||
|
||||
/// 🔴 `base_visual_dev` / `base_visual_release` 的**共同列清单**与**类型**。
|
||||
///
|
||||
/// 官方两表逐列相同(`base_visual_release` 只多一列 `f_old_content`)
|
||||
/// ⇒ 用同一份清单写两张表 ⇒ 少一处漂移。
|
||||
///
|
||||
/// 🔴 每列带一个**列类型标记**(决定 SQL 里补哪层 cast):
|
||||
///
|
||||
/// | 标记 | 物理类型 | 参数 cast |
|
||||
/// |---|---|---|
|
||||
/// | `text` | `TEXT` / `VARCHAR` | `::text` |
|
||||
/// | `int` | `INTEGER` | `::text::integer` |
|
||||
/// | `bigint` | `BIGINT` | `::text::bigint` |
|
||||
/// | `ts` | `TIMESTAMP(0)` | `::text::timestamp` |
|
||||
///
|
||||
/// 🔴 **为什么参数统一按字符串送**:pglite 的扩展查询协议里,未标注类型的参数
|
||||
/// 会被服务端当成 `text`;本仓的整型/时间戳列需要显式再转一层。
|
||||
/// 列类型标记与清单**同序** ⇒ 少一处可能对不上的地方。
|
||||
const VISUAL_COLUMNS: &[(&str, &str)] = &[
|
||||
("f_id", "text"),
|
||||
("f_full_name", "text"),
|
||||
("f_en_code", "text"),
|
||||
("f_state", "int"),
|
||||
("f_type", "int"),
|
||||
("f_tables_data", "text"),
|
||||
("f_form_data", "text"),
|
||||
("f_column_data", "text"),
|
||||
("f_web_type", "int"),
|
||||
("f_app_column_data", "text"),
|
||||
("f_enable_flow", "int"),
|
||||
("f_description", "text"),
|
||||
("f_enabled_mark", "int"),
|
||||
("f_sort_code", "bigint"),
|
||||
("f_creator_time", "ts"),
|
||||
("f_creator_user_id", "text"),
|
||||
("f_last_modify_time", "ts"),
|
||||
("f_last_modify_user_id", "text"),
|
||||
("f_delete_mark", "int"),
|
||||
("f_tenant_id", "text"),
|
||||
("f_url_address", "text"),
|
||||
("f_web_address", "text"),
|
||||
("f_button_data", "text"),
|
||||
("f_system_id", "text"),
|
||||
];
|
||||
|
||||
/// 种子结果。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SeedOutcome {
|
||||
/// 功能 id(`base_visual_dev.f_id`)。
|
||||
pub form_id: String,
|
||||
/// 功能编码。
|
||||
pub en_code: String,
|
||||
/// 建出来的表(主表在前)。
|
||||
pub tables: Vec<String>,
|
||||
/// 已存在因而跳过的表。
|
||||
pub skipped: Vec<String>,
|
||||
/// 实际执行的 DDL。
|
||||
pub ddl: Vec<String>,
|
||||
/// 回写后的模型(`f_tables_data` 的新值)。
|
||||
pub model: Value,
|
||||
/// 诊断信息。
|
||||
pub notes: Vec<String>,
|
||||
/// 是否只是演练(没建表、没写库)。
|
||||
pub dry_run: bool,
|
||||
}
|
||||
|
||||
/// 🔴 **档位闸门**:只在开发档允许。
|
||||
///
|
||||
/// `SSW_PROFILE=prod`(或 `production`)⇒ 拒绝。
|
||||
///
|
||||
/// 理由:这条命令会**建表**(改真实库结构)并灌入示例数据 ——
|
||||
/// 生产库里既不该有示例表,也不该在启动期被一条命令改结构。
|
||||
///
|
||||
/// 纯函数 ⇒ 可单测(不依赖环境变量)。
|
||||
pub fn seed_gate(profile: Profile) -> Result<(), String> {
|
||||
match profile {
|
||||
Profile::Dev => Ok(()),
|
||||
Profile::Prod => Err(
|
||||
"--seed-lowcode-demo 只在开发档可用(SSW_PROFILE=prod/production)。\n\
|
||||
它会往库里**建表**并灌入示例数据 —— 生产库不该有这些。\n\
|
||||
确实要跑 ⇒ 把 SSW_PROFILE 改成 dev(或 unset),\
|
||||
并确认 PGLITE_DIR 指向的是开发库而不是生产库。"
|
||||
.to_string(),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
/// fixture 的绝对路径(相对项目根)。
|
||||
pub fn fixture_path(project_dir: &Path, name: &str) -> PathBuf {
|
||||
project_dir.join(name)
|
||||
}
|
||||
|
||||
/// 🔴 读 fixture 文件。
|
||||
fn read_fixture(project_dir: &Path, rel: &str) -> Result<String, ToolError> {
|
||||
let path = fixture_path(project_dir, rel);
|
||||
std::fs::read_to_string(&path).map_err(|e| {
|
||||
ToolError::new(
|
||||
"FIXTURE_MISSING",
|
||||
format!("读不到官方 fixture:{}({e})", path.display()),
|
||||
)
|
||||
.field(rel)
|
||||
.hint("fixture 在 crates/sspf-lowcode/tests/fixtures/ 下,与基线平台初始化 SQL 同源")
|
||||
})
|
||||
}
|
||||
|
||||
/// 🔴 读官方 fixture,解析出(表单, 模型)。
|
||||
///
|
||||
/// 两个入口共用这一段 ⇒ 演练看到的与真跑执行的**一定是同一份设计稿**。
|
||||
fn load_demo_fixture(
|
||||
project_dir: &Path,
|
||||
) -> Result<(FormSchema, ModelSchema), ToolError> {
|
||||
let form_text = read_fixture(project_dir, FORM_FIXTURE)?;
|
||||
let model_text = read_fixture(project_dir, MODEL_FIXTURE)?;
|
||||
|
||||
let form = FormSchema::from_str(&form_text).map_err(|e| {
|
||||
ToolError::new(
|
||||
e.code(),
|
||||
format!("官方表单 fixture 解析失败: {}", e.message()),
|
||||
)
|
||||
.field(FORM_FIXTURE)
|
||||
})?;
|
||||
let model = ModelSchema::from_str(&model_text).map_err(|e| {
|
||||
ToolError::new(
|
||||
e.code(),
|
||||
format!("官方模型 fixture 解析失败: {}", e.message()),
|
||||
)
|
||||
.field(MODEL_FIXTURE)
|
||||
})?;
|
||||
|
||||
Ok((form, model))
|
||||
}
|
||||
|
||||
/// 🔴 **演练**:只看要建什么表,**不碰库**。
|
||||
///
|
||||
/// 🔴 **连数据库都不开** —— 演练的整个意义就是「什么都不发生」。
|
||||
/// 开库就意味着在数据目录里落一个临时 PG 实例(改磁盘状态)。
|
||||
pub fn preview_lowcode_demo(project_dir: &Path) -> Result<SeedOutcome, ToolError> {
|
||||
let (form, model) = load_demo_fixture(project_dir)?;
|
||||
let ddl = lowcode_ddl::preview_ddl(&model, &form)?;
|
||||
|
||||
let planned: Vec<String> = model
|
||||
.tables
|
||||
.iter()
|
||||
.map(|t| t.table.to_lowercase())
|
||||
.collect();
|
||||
|
||||
Ok(SeedOutcome {
|
||||
form_id: DEMO_ID.to_string(),
|
||||
en_code: DEMO_EN_CODE.to_string(),
|
||||
tables: planned,
|
||||
skipped: Vec::new(),
|
||||
ddl,
|
||||
model: model.raw.clone(),
|
||||
notes: vec!["dry-run:没有建表,也没有写库".to_string()],
|
||||
dry_run: true,
|
||||
})
|
||||
}
|
||||
|
||||
/// 🔴 低代码示例功能种子(**开发档专用**)。
|
||||
///
|
||||
/// ## 执行顺序(顺序不能换)
|
||||
///
|
||||
/// 1. 读官方 fixture(表单 + 模型);
|
||||
/// 2. 先写 `base_visual_dev`(**用原始模型**)—— 因为建表后的回写要求这行已存在;
|
||||
/// 3. `create_and_sync`:建表 + 回写 `f_tables_data`(含系统列);
|
||||
/// 4. 写 `base_visual_release`(**用回写后的模型**)—— 发布快照与 dev 一致。
|
||||
pub async fn seed_lowcode_demo(
|
||||
db: &Db,
|
||||
project_dir: &Path,
|
||||
) -> Result<SeedOutcome, ToolError> {
|
||||
let (form, model) = load_demo_fixture(project_dir)?;
|
||||
|
||||
// ---- DDL 预览(与真实执行用同一套生成规则)----
|
||||
let ddl = lowcode_ddl::preview_ddl(&model, &form)?;
|
||||
|
||||
// ---- 1. 先写 dev 行(原始模型)----
|
||||
upsert_visual_row(db, "base_visual_dev", DEMO_ID, &form.raw.to_string(), &model.raw.to_string())
|
||||
.await?;
|
||||
|
||||
// ---- 2. 建表 + 回写模型 ----
|
||||
let created = lowcode_ddl::create_and_sync(db, DEMO_ID, &model, &form, false).await?;
|
||||
|
||||
// ---- 3. 写 release 行(**回写后**的模型 ⇒ 与 dev 一致)----
|
||||
let rewritten_text = serde_json::to_string(&created.model).map_err(|e| {
|
||||
ToolError::new(
|
||||
"MODEL_SERIALIZE_FAILED",
|
||||
format!("回写后的模型序列化失败: {e}"),
|
||||
)
|
||||
})?;
|
||||
upsert_visual_row(
|
||||
db,
|
||||
"base_visual_release",
|
||||
DEMO_ID,
|
||||
&form.raw.to_string(),
|
||||
&rewritten_text,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let mut notes = created.notes.clone();
|
||||
notes.push(format!(
|
||||
"功能定义已写入 base_visual_dev 与 base_visual_release(id={DEMO_ID}, enCode={DEMO_EN_CODE})"
|
||||
));
|
||||
|
||||
Ok(SeedOutcome {
|
||||
form_id: DEMO_ID.to_string(),
|
||||
en_code: DEMO_EN_CODE.to_string(),
|
||||
tables: created.tables,
|
||||
skipped: created.skipped,
|
||||
ddl,
|
||||
model: created.model,
|
||||
notes,
|
||||
dry_run: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// 🔴 写(插入或更新)一行低代码功能定义。
|
||||
///
|
||||
/// ## 🔴 幂等策略
|
||||
///
|
||||
/// 「先查存在性,再决定 INSERT 还是 UPDATE」——
|
||||
/// `Db::exec_params` **不返回影响行数**(pglite 0.2.7 没这个能力),
|
||||
/// 所以不能用 `ON CONFLICT ... DO UPDATE`(那样也拿不到结果),
|
||||
/// 只能先 `SELECT` 判存在。
|
||||
async fn upsert_visual_row(
|
||||
db: &Db,
|
||||
table: &str,
|
||||
id: &str,
|
||||
form_data: &str,
|
||||
tables_data: &str,
|
||||
) -> Result<(), ToolError> {
|
||||
let exists = db
|
||||
.query_json_params(
|
||||
&format!("SELECT 1 AS \"x\" FROM {table} WHERE f_id = $1 LIMIT 1"),
|
||||
&[&id.to_string()],
|
||||
)
|
||||
.await
|
||||
.map_err(db_err)?;
|
||||
|
||||
if exists.is_empty() {
|
||||
insert_visual_row(db, table, id, form_data, tables_data).await?;
|
||||
} else {
|
||||
update_visual_row(db, table, id, form_data, tables_data).await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 🔴 一行的**字段值**(与 [`VISUAL_COLUMNS`] 同序)。
|
||||
fn visual_row_values(id: &str, form_data: &str, tables_data: &str) -> Vec<String> {
|
||||
let now = now_iso();
|
||||
let url = format!("lowcode/{DEMO_EN_CODE}/index");
|
||||
vec![
|
||||
id.to_string(),
|
||||
DEMO_FULL_NAME.to_string(),
|
||||
DEMO_EN_CODE.to_string(),
|
||||
"1".to_string(), // f_state:1 = 已发布
|
||||
"1".to_string(), // f_type:1 = 在线开发
|
||||
tables_data.to_string(),
|
||||
form_data.to_string(),
|
||||
"[]".to_string(), // f_column_data:列表列(空数组 = 不配列表页)
|
||||
"2".to_string(), // f_web_type:2 = PC 端
|
||||
"[]".to_string(), // f_app_column_data
|
||||
"0".to_string(), // f_enable_flow
|
||||
"开发期种子生成的低代码示例功能".to_string(),
|
||||
"1".to_string(), // f_enabled_mark
|
||||
"0".to_string(), // f_sort_code
|
||||
now.clone(), // f_creator_time
|
||||
"admin".to_string(),
|
||||
now.clone(), // f_last_modify_time
|
||||
"admin".to_string(),
|
||||
"0".to_string(), // f_delete_mark
|
||||
TENANT_ID.to_string(),
|
||||
url.clone(),
|
||||
url,
|
||||
"[]".to_string(), // f_button_data
|
||||
MAIN_SYSTEM_ID.to_string(),
|
||||
]
|
||||
}
|
||||
|
||||
/// 🔴 插入一行低代码功能定义。
|
||||
async fn insert_visual_row(
|
||||
db: &Db,
|
||||
table: &str,
|
||||
id: &str,
|
||||
form_data: &str,
|
||||
tables_data: &str,
|
||||
) -> Result<(), ToolError> {
|
||||
let values = visual_row_values(id, form_data, tables_data);
|
||||
let cols: Vec<&str> = VISUAL_COLUMNS.iter().map(|(c, _)| *c).collect();
|
||||
let placeholders: Vec<String> = VISUAL_COLUMNS
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, (_, ty))| format!("${}::{}", i + 1, cast_for(ty)))
|
||||
.collect();
|
||||
|
||||
let sql = format!(
|
||||
"INSERT INTO {table} ({}) VALUES ({})",
|
||||
cols.join(", "),
|
||||
placeholders.join(", ")
|
||||
);
|
||||
|
||||
let refs = build_params(&values);
|
||||
db.exec_params(&sql, &refs).await.map_err(db_err)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 🔴 更新一行低代码功能定义(只改「这个功能真的用到」的列)。
|
||||
async fn update_visual_row(
|
||||
db: &Db,
|
||||
table: &str,
|
||||
id: &str,
|
||||
form_data: &str,
|
||||
tables_data: &str,
|
||||
) -> Result<(), ToolError> {
|
||||
let values = visual_row_values(id, form_data, tables_data);
|
||||
let now = now_iso();
|
||||
|
||||
// 🔴 列清单里除 `f_id` 外全部更新(`f_creator_*` 保持首次种下的值)。
|
||||
// 参数编号要与 `set_cols` 的顺序严格对应 ⇒ 按 `VISUAL_COLUMNS` 里的下标取。
|
||||
let mut params: Vec<String> = Vec::new();
|
||||
let mut assignments: Vec<String> = Vec::new();
|
||||
for (i, (col, ty)) in VISUAL_COLUMNS.iter().enumerate() {
|
||||
if *col == "f_id" || *col == "f_creator_time" || *col == "f_creator_user_id" {
|
||||
continue;
|
||||
}
|
||||
// 🔴 `f_last_modify_time` 用**当前**时间(其余值原样回填)。
|
||||
let value = if *col == "f_last_modify_time" {
|
||||
now.clone()
|
||||
} else {
|
||||
values[i].clone()
|
||||
};
|
||||
params.push(value);
|
||||
assignments.push(format!("{col} = ${}::{}", params.len(), cast_for(ty)));
|
||||
}
|
||||
params.push(id.to_string());
|
||||
let id_pos = params.len();
|
||||
|
||||
let sql = format!(
|
||||
"UPDATE {table} SET {} WHERE f_id = ${id_pos}::text",
|
||||
assignments.join(", ")
|
||||
);
|
||||
|
||||
let refs = build_params(¶ms);
|
||||
db.exec_params(&sql, &refs).await.map_err(db_err)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 🔴 列类型标记 ⇒ SQL cast 片段。
|
||||
fn cast_for(kind: &str) -> &'static str {
|
||||
match kind {
|
||||
"int" => "text::integer",
|
||||
"bigint" => "text::bigint",
|
||||
"ts" => "text::timestamp",
|
||||
_ => "text",
|
||||
}
|
||||
}
|
||||
|
||||
/// 🔴 把参数向量转成可传给 `exec_params` 的引用数组。
|
||||
fn build_params(params: &[String]) -> Vec<&(dyn pglite::ToSql + Sync)> {
|
||||
params
|
||||
.iter()
|
||||
.map(|s| s as &(dyn pglite::ToSql + Sync))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 🔴 DB 错误转工具错误。
|
||||
fn db_err(e: pglite::Error) -> ToolError {
|
||||
ToolError::new("DB_ERROR", format!("数据库错误:{e}"))
|
||||
.hint("先确认数据库连接正常;这个错误通常来自 SQL 或连接配置")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// 🔴 **开发档放行**。
|
||||
#[test]
|
||||
fn dev_profile_is_allowed() {
|
||||
assert!(seed_gate(Profile::Dev).is_ok());
|
||||
}
|
||||
|
||||
/// 🔴 **生产档拒绝**(且要说得清为什么、怎么办)。
|
||||
#[test]
|
||||
fn prod_profile_is_rejected_with_guidance() {
|
||||
let err = seed_gate(Profile::Prod).unwrap_err();
|
||||
assert!(err.contains("SSW_PROFILE"), "报错要指明用哪个环境变量:{err}");
|
||||
assert!(err.contains("PGLITE_DIR"), "报错要提醒别指到生产库:{err}");
|
||||
}
|
||||
|
||||
/// 🔴 闸门**只认档位**,不读环境变量 ⇒ 纯函数、可单测。
|
||||
#[test]
|
||||
fn gate_depends_only_on_profile() {
|
||||
assert!(seed_gate(Profile::from_env_str("dev")).is_ok());
|
||||
assert!(seed_gate(Profile::from_env_str("")).is_ok());
|
||||
assert!(seed_gate(Profile::from_env_str("prod")).is_err());
|
||||
assert!(seed_gate(Profile::from_env_str("PRODUCTION")).is_err());
|
||||
}
|
||||
|
||||
/// 🔴 **列清单与字段值必须一一对应** —— 对不上会静默写错列。
|
||||
#[test]
|
||||
fn column_list_matches_value_count() {
|
||||
let values = visual_row_values("id", "form", "tables");
|
||||
assert_eq!(
|
||||
VISUAL_COLUMNS.len(),
|
||||
values.len(),
|
||||
"VISUAL_COLUMNS 的长度变了 ⇒ 同步改 visual_row_values"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 **列清单的 id 列必须是第一列** —— `UPDATE` 靠这个下标排除它。
|
||||
#[test]
|
||||
fn first_column_is_id() {
|
||||
assert_eq!(VISUAL_COLUMNS[0].0, "f_id");
|
||||
}
|
||||
|
||||
/// 🔴 cast 片段必须与列类型对得上(写错 ⇒ PG 类型错)。
|
||||
#[test]
|
||||
fn cast_for_matches_column_kinds() {
|
||||
assert_eq!(cast_for("text"), "text");
|
||||
assert_eq!(cast_for("int"), "text::integer");
|
||||
assert_eq!(cast_for("bigint"), "text::bigint");
|
||||
assert_eq!(cast_for("ts"), "text::timestamp");
|
||||
}
|
||||
|
||||
/// 🔴 fixture 路径拼在**项目根**下(不依赖 cwd)。
|
||||
#[test]
|
||||
fn fixture_path_is_under_project_root() {
|
||||
let p = fixture_path(Path::new("/tmp/proj"), FORM_FIXTURE);
|
||||
assert!(p.starts_with("/tmp/proj"), "{}", p.display());
|
||||
assert!(p.ends_with("sample_form.json"), "{}", p.display());
|
||||
}
|
||||
}
|
||||
+245
-16
@@ -81,6 +81,12 @@ enum Cmd {
|
||||
/// `with_http` 为真时**同时**起 HTTP —— 同一个进程、同一个 `AppState`、同一个库,
|
||||
/// AI 通过 MCP 写完数据,浏览器刷新就能看到(人机协作的关键手感)。
|
||||
Mcp { with_http: bool },
|
||||
/// `--seed-lowcode-demo [--dry-run]` ⇒ 灌入低代码示例功能(**开发档专用**)。
|
||||
///
|
||||
/// 🔴 这条命令会**建表**(改真实库结构)⇒ 生产档(`SSW_PROFILE=prod`)直接拒绝。
|
||||
///
|
||||
/// `dry_run` 为真时只产出 DDL 与诊断信息,**不碰库**。
|
||||
SeedLowcodeDemo { dry_run: bool },
|
||||
/// 未知参数 ⇒ 用法错,退出码 **2**。
|
||||
Unknown(String),
|
||||
/// 无参数 ⇒ 起服务。
|
||||
@@ -102,6 +108,8 @@ enum RunMode {
|
||||
/// - `["--enc", <明文>]` ⇒ `Cmd::Enc`(退出码 0);
|
||||
/// - `["--enc"]`(缺明文)⇒ `Cmd::EncMissing`(退出码 2 + 人话提示);
|
||||
/// - `["--help"]` / `["-h"]` ⇒ `Cmd::Help`(退出码 0);
|
||||
/// - `["--seed-lowcode-demo"]` / `["--seed-lowcode-demo", "--dry-run"]`
|
||||
/// ⇒ `Cmd::SeedLowcodeDemo`(退出码 0;生产档执行期拒绝 ⇒ 1);
|
||||
/// - `["<其它>"]` ⇒ `Cmd::Unknown`(退出码 2);
|
||||
/// - `[]` ⇒ `Cmd::Serve`。
|
||||
fn parse_args(args: &[String]) -> Cmd {
|
||||
@@ -114,6 +122,10 @@ fn parse_args(args: &[String]) -> Cmd {
|
||||
// `--with-http` 只在 `--mcp` 之后有意义;位置写错就当没给。
|
||||
with_http: args.get(1).map(String::as_str) == Some("--with-http"),
|
||||
},
|
||||
Some("--seed-lowcode-demo") => Cmd::SeedLowcodeDemo {
|
||||
// `--dry-run` 只在 `--seed-lowcode-demo` 之后有意义;位置写错就当没给。
|
||||
dry_run: args.get(1).map(String::as_str) == Some("--dry-run"),
|
||||
},
|
||||
Some("--help") | Some("-h") => Cmd::Help,
|
||||
Some(other) => Cmd::Unknown(other.to_string()),
|
||||
None => Cmd::Serve,
|
||||
@@ -127,7 +139,7 @@ fn exit_code(cmd: &Cmd) -> i32 {
|
||||
match cmd {
|
||||
Cmd::Enc(_) | Cmd::Help => 0,
|
||||
Cmd::EncMissing | Cmd::Unknown(_) => 2,
|
||||
Cmd::Serve | Cmd::Mcp { .. } => 0,
|
||||
Cmd::Serve | Cmd::Mcp { .. } | Cmd::SeedLowcodeDemo { .. } => 0,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -156,6 +168,11 @@ async fn main() {
|
||||
print_usage();
|
||||
std::process::exit(exit_code(&cmd));
|
||||
}
|
||||
// 🔴 开发期种子:走**独立**的装配路径(不开 HTTP、不起 MCP),
|
||||
// 做完就退出 ⇒ 不会有人以为「跑种子」= 「起服务」。
|
||||
Cmd::SeedLowcodeDemo { dry_run } => {
|
||||
std::process::exit(run_seed_lowcode_demo(*dry_run).await);
|
||||
}
|
||||
// 两个「起服务」形态共用同一套装配(见 `run`),只是收尾不同。
|
||||
Cmd::Serve | Cmd::Mcp { .. } => {}
|
||||
}
|
||||
@@ -183,12 +200,136 @@ fn print_usage() {
|
||||
println!(" ssw-platform --mcp 启动 MCP stdio 服务(供 AI 驱动,不监听端口)");
|
||||
println!(" ssw-platform --mcp --with-http 同时起 MCP 与 HTTP(同一进程、同一个库)");
|
||||
println!(" ssw-platform --enc <明文> 打印登录口令密文(hex),退出码 0");
|
||||
println!(" ssw-platform --seed-lowcode-demo 灌入低代码示例功能(开发档专用,建表 + 写功能定义)");
|
||||
println!(" ssw-platform --seed-lowcode-demo --dry-run 只看要建什么表,不碰库");
|
||||
println!(" ssw-platform --help 打印本用法,退出码 0");
|
||||
println!();
|
||||
println!("环境变量:");
|
||||
println!(" PORT 监听端口(缺省 30010)");
|
||||
println!(" BIND_ADDR 监听地址(缺省 127.0.0.1 = 只监听本机;要对外暴露设 0.0.0.0)");
|
||||
println!(" PGLITE_DIR pglite 数据目录;设成 memory:// 用临时库(进程退出即销毁)");
|
||||
println!(" SSW_PROFILE 部署档位(prod/production = 生产档;缺省 = 开发档)");
|
||||
}
|
||||
|
||||
/// 🔴 开发期低代码种子(`--seed-lowcode-demo`)—— **做完就退出**。
|
||||
///
|
||||
/// ## 🔴 三道闸门(顺序不能换)
|
||||
///
|
||||
/// 1. **档位闸门**:生产档(`SSW_PROFILE=prod`)⇒ 直接拒绝,**不开库**
|
||||
/// (连数据目录都不碰 —— 生产库不该被一条命令改结构);
|
||||
/// 2. **白名单自检**(同 `run()` 的第 3 步)—— 与服务启动走**同一把尺子**;
|
||||
/// 3. 建表 + 回写(`lowcode_ddl::create_and_sync`)⇒ 幂等。
|
||||
///
|
||||
/// ## 退出码
|
||||
///
|
||||
/// - **0**:成功;
|
||||
/// - **1**:闸门拒绝 / 建表失败 / 写库失败(都有人话提示)。
|
||||
///
|
||||
/// 🔴 不复用 `run()`:那条路会**起 HTTP 监听**、跑完整种子 —— 而这里只想
|
||||
/// 「种完就退出」,起服务既没意义又会占端口。
|
||||
async fn run_seed_lowcode_demo(dry_run: bool) -> i32 {
|
||||
// ---- 第 1 步:项目根(与 cwd 解耦)----
|
||||
let project_dir = resolve_project_dir();
|
||||
|
||||
// ---- 第 2 步:配置(只取档位与数据目录)----
|
||||
let config = Config::from_env(project_dir.clone());
|
||||
|
||||
// ---- 第 3 步:档位闸门(**开库之前**)----
|
||||
if let Err(msg) = ssw_platform::lowcode_seed::seed_gate(config.profile) {
|
||||
eprintln!("[种子拒绝] {msg}");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// ---- 第 3b 步:演练 ⇒ **连库都不开**(什么都不发生)----
|
||||
if dry_run {
|
||||
let outcome = match ssw_platform::lowcode_seed::preview_lowcode_demo(&project_dir) {
|
||||
Ok(o) => o,
|
||||
Err(e) => {
|
||||
eprintln!("[种子预览失败] {}:{}", e.code, e.message);
|
||||
for h in &e.hints {
|
||||
eprintln!(" · {h}");
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
print_seed_outcome(&outcome);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ---- 第 4 步:白名单自检(与起服务同一把尺子)----
|
||||
if let Err(msg) = whitelist_self_check() {
|
||||
eprintln!("[种子失败] 标识符白名单自检未通过: {msg}");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// ---- 第 5 步:开库 + 建表 ----
|
||||
let db = match open_db(&config).await {
|
||||
Ok(db) => db,
|
||||
Err(e) => {
|
||||
eprintln!("[种子失败] 打开数据库失败: {e}");
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
if let Err(e) = db.ensure_schema().await {
|
||||
eprintln!("[种子失败] 初始化表结构失败: {e}");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// ---- 第 6 步:灌种子 ----
|
||||
let outcome = match ssw_platform::lowcode_seed::seed_lowcode_demo(&db, &project_dir).await {
|
||||
Ok(o) => o,
|
||||
Err(e) => {
|
||||
eprintln!("[种子失败] {}:{}", e.code, e.message);
|
||||
for h in &e.hints {
|
||||
eprintln!(" · {h}");
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
// ---- 第 7 步:人话汇报 ----
|
||||
print_seed_outcome(&outcome);
|
||||
|
||||
// 🔴 停机:**与起服务同一条路径**(优雅关闭嵌入式 PG)——
|
||||
// 否则数据目录里会留 `postmaster.pid`,下次启动要 crash recovery。
|
||||
shutdown_pg(&db, &config.pg_dir).await;
|
||||
|
||||
0
|
||||
}
|
||||
|
||||
/// 🔴 把种子结果打印成人话(演练与真跑共用一份汇报口径)。
|
||||
fn print_seed_outcome(outcome: &ssw_platform::lowcode_seed::SeedOutcome) {
|
||||
println!(
|
||||
"{} 低代码示例功能(id={},enCode={})",
|
||||
if outcome.dry_run {
|
||||
"[种子预览]"
|
||||
} else {
|
||||
"[种子完成]"
|
||||
},
|
||||
outcome.form_id,
|
||||
outcome.en_code
|
||||
);
|
||||
if !outcome.tables.is_empty() {
|
||||
let verb = if outcome.dry_run { "将要建" } else { "已建" };
|
||||
println!(" {verb}的表:{}", outcome.tables.join(", "));
|
||||
}
|
||||
if !outcome.skipped.is_empty() {
|
||||
println!(" 已存在(幂等跳过):{}", outcome.skipped.join(", "));
|
||||
}
|
||||
if !outcome.dry_run {
|
||||
for sql in &outcome.ddl {
|
||||
println!(" · {sql}");
|
||||
}
|
||||
}
|
||||
for n in &outcome.notes {
|
||||
println!(" · {n}");
|
||||
}
|
||||
if !outcome.dry_run {
|
||||
println!(
|
||||
" 接着可以试:data.record.insert {{\"enCode\":\"{}\",\"data\":{{\"F_Room\":\"A-101\"}},\"dryRun\":true}}",
|
||||
outcome.en_code
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// 把标准流整个让给内嵌 PostgreSQL,返回**复制出来**的协议通道(读, 写)。
|
||||
@@ -416,25 +557,38 @@ async fn run(mode: RunMode) -> Result<(), String> {
|
||||
.map_err(|e| format!("HTTP 服务异常退出: {e}"))?;
|
||||
|
||||
// ---- 停机:优雅关闭嵌入式 PostgreSQL ----
|
||||
// 🔴 **不 await** pglite 的关闭 future:pglite-rs 0.2.7 的 `PGlite::shutdown()` 给嵌入式 PG
|
||||
// 发完 Terminate 之后**不会返回** —— PG 的 postmaster 会进入「拉起后端 → 后端读不到
|
||||
// 完整协议 → FATAL → 再拉起」的循环(实测一次停机刷 30 多万行日志),收尾线程卡死在那儿。
|
||||
// ⇒ 另起任务去发 Terminate,同时**盯住 `postmaster.pid` 何时消失**
|
||||
// (PG 干净关库的**权威信号**)⇒ 一旦消失就立刻结束进程
|
||||
// (顺带把 pglite 那段日志噪声压到最小)。
|
||||
let shutdown_db = db_for_shutdown.clone();
|
||||
shutdown_pg(&db_for_shutdown, &config.pg_dir).await;
|
||||
|
||||
// 🔴 明确结束进程:pglite 的收尾线程可能卡死 ⇒ 不能让它吊住整个进程。
|
||||
std::process::exit(0);
|
||||
}
|
||||
|
||||
/// 🔴 **优雅关闭嵌入式 PostgreSQL**(起服务与跑种子共用同一条路径)。
|
||||
///
|
||||
/// ## 🔴 为什么**不 await** pglite 的关闭 future
|
||||
///
|
||||
/// pglite-rs 0.2.7 的 `PGlite::shutdown()` 给嵌入式 PG 发完 Terminate 之后
|
||||
/// **不会返回** —— PG 的 postmaster 会进入「拉起后端 → 后端读不到完整协议 →
|
||||
/// FATAL → 再拉起」的循环(实测一次停机刷 30 多万行日志),收尾线程卡死在那儿。
|
||||
/// ⇒ 另起任务去发 Terminate,同时**盯住 `postmaster.pid` 何时消失**
|
||||
/// (PG 干净关库的**权威信号**)⇒ 一旦消失就立刻返回。
|
||||
///
|
||||
/// ## 🔴 为什么**不**报「已优雅关闭」除非校验过
|
||||
///
|
||||
/// `postmaster.pid` 一开始就不在 ⇒ 两种含义完全不同:
|
||||
/// ① 数据目录已知、PG 刚关完(`postmaster.pid` 已被 PG 自己删掉);
|
||||
/// ② 临时库模式(`PGLITE_DIR=memory://`)⇒ `pg_dir` 就是字面量 `"memory://"`,
|
||||
/// 拼出来的 `"memory://postmaster.pid"` **永远不存在** ⇒ 关库状态**无从校验**。
|
||||
/// ⇒ ② 只能如实说「未校验」,不能报「已优雅关闭」(那是**没校验过**的断言)。
|
||||
async fn shutdown_pg(db: &Db, pg_dir: &std::path::Path) {
|
||||
let shutdown_db = db.clone();
|
||||
tokio::spawn(async move {
|
||||
if let Err(e) = shutdown_db.shutdown().await {
|
||||
eprintln!("[停机] 关闭嵌入式 PostgreSQL 失败: {e}");
|
||||
}
|
||||
});
|
||||
|
||||
let pid_file = config.pg_dir.join("postmaster.pid");
|
||||
// 🔴 **先记下 pid 文件一开始在不在** —— 「不在」有两种含义,含义不同、结论也不同:
|
||||
// ① 数据目录已知、PG 刚关完(`postmaster.pid` 已被 PG 自己删掉);
|
||||
// ② 临时库模式(`PGLITE_DIR=memory://`)⇒ `pg_dir` 就是字面量 "memory://",
|
||||
// 拼出来的 "memory://postmaster.pid" **永远不存在** ⇒ 关库状态**无从校验**。
|
||||
// ⇒ ② 不能报「已优雅关闭」(那是**没校验过**的断言),只能如实说「未校验」。
|
||||
let pid_file = pg_dir.join("postmaster.pid");
|
||||
let pid_file_known = pid_file.exists();
|
||||
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(3);
|
||||
if pid_file_known {
|
||||
@@ -455,8 +609,6 @@ async fn run(mode: RunMode) -> Result<(), String> {
|
||||
} else {
|
||||
println!("ssw-platform 已停止(嵌入式 PostgreSQL 已优雅关闭)。");
|
||||
}
|
||||
// 🔴 明确结束进程:pglite 的收尾线程可能卡死 ⇒ 不能让它吊住整个进程。
|
||||
std::process::exit(0);
|
||||
}
|
||||
|
||||
/// 等待**停机信号**(SIGTERM / SIGINT)—— 任一到来即返回。
|
||||
@@ -581,7 +733,45 @@ fn whitelist_self_check() -> Result<(), String> {
|
||||
}
|
||||
|
||||
/// 开库:`PGLITE_DIR=memory://` ⇒ 临时库(进程退出即销毁);否则磁盘目录。
|
||||
/// pglite 0.2.7 内嵌的 PostgreSQL 在 boot 阶段(`pq_init → WaitEventAdjustKqueue`)
|
||||
/// 会对 fd 1 注册 kqueue 读事件。若 fd 1 是字符设备(如 `/dev/null`)或已关闭,
|
||||
/// `kevent()` 会失败;又因 `pgl_startPGlite` 不在 `sigsetjmp` 上下文,错误会回落成
|
||||
/// `pgl_native_exit(100)`,并以残留 `postmaster.pid`、退出码 100 收场。
|
||||
///
|
||||
/// 修复:开库前若 fd 1 不是「普通文件 / 管道 / 套接字 / 终端」这类可安全用于 kqueue 的
|
||||
/// 类型,就把它重定向到一个匿名普通临时文件(进程级,泄漏以保活 fd)。
|
||||
/// 仅在真正需要时动手,正常 `> file` / `| pipe` / 终端场景完全不动,避免影响输出与 MCP 协议通道
|
||||
/// (MCP 协议走 `dup` 出来的独立 fd,不依赖 fd 1)。
|
||||
#[cfg(unix)]
|
||||
fn ensure_stdout_for_pglite() {
|
||||
use std::os::unix::io::AsRawFd;
|
||||
unsafe {
|
||||
let mut st: libc::stat = std::mem::zeroed();
|
||||
let bad = libc::fstat(libc::STDOUT_FILENO, &mut st) != 0
|
||||
|| (st.st_mode & libc::S_IFMT) == libc::S_IFCHR;
|
||||
if !bad {
|
||||
return;
|
||||
}
|
||||
// 开一个普通临时文件当作 stdout 落点(append,内容无人在意)。
|
||||
let tmp = std::env::temp_dir()
|
||||
.join(format!("ssw-pglite-stdout-{}.log", std::process::id()));
|
||||
match std::fs::OpenOptions::new().create(true).append(true).open(&tmp) {
|
||||
Ok(f) => {
|
||||
// 泄漏 fd 以保证 fd 1 在整个进程生命周期内有效(指向普通文件)。
|
||||
let _ = libc::dup2(f.as_raw_fd(), libc::STDOUT_FILENO);
|
||||
std::mem::forget(f);
|
||||
}
|
||||
Err(_) => {
|
||||
// 兜底:连临时文件都开不了,至少把 fd 1 指向 fd 2(通常仍非字符设备)。
|
||||
let _ = libc::dup2(libc::STDERR_FILENO, libc::STDOUT_FILENO);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn open_db(config: &Config) -> Result<Db, pglite::Error> {
|
||||
#[cfg(unix)]
|
||||
ensure_stdout_for_pglite();
|
||||
if config.pg_is_temp() {
|
||||
Db::open_temp().await
|
||||
} else {
|
||||
@@ -631,6 +821,45 @@ mod tests {
|
||||
assert_eq!(exit_code(&cmd), 2);
|
||||
}
|
||||
|
||||
/// 🔴 `--seed-lowcode-demo` ⇒ 种低代码示例功能,退出码 **0**。
|
||||
#[test]
|
||||
fn seed_lowcode_demo_is_recognized() {
|
||||
let cmd = parse_args(&args(&["--seed-lowcode-demo"]));
|
||||
assert_eq!(cmd, Cmd::SeedLowcodeDemo { dry_run: false });
|
||||
assert_eq!(exit_code(&cmd), 0);
|
||||
}
|
||||
|
||||
/// 🔴 `--seed-lowcode-demo --dry-run` ⇒ 演练模式(不碰库)。
|
||||
#[test]
|
||||
fn seed_lowcode_demo_supports_dry_run() {
|
||||
let cmd = parse_args(&args(&["--seed-lowcode-demo", "--dry-run"]));
|
||||
assert_eq!(cmd, Cmd::SeedLowcodeDemo { dry_run: true });
|
||||
assert_eq!(exit_code(&cmd), 0);
|
||||
}
|
||||
|
||||
/// 🔴 `--dry-run` 写在 `--seed-lowcode-demo` **之前** ⇒ 当没给
|
||||
/// (与 `--mcp --with-http` 的位置约定同款)。
|
||||
#[test]
|
||||
fn dry_run_flag_position_matters() {
|
||||
let cmd = parse_args(&args(&["--dry-run", "--seed-lowcode-demo"]));
|
||||
assert_eq!(cmd, Cmd::Unknown("--dry-run".to_string()));
|
||||
assert_eq!(exit_code(&cmd), 2);
|
||||
}
|
||||
|
||||
/// 🔴 **生产档拒绝跑种子**(纯函数闸门,不开库)。
|
||||
#[test]
|
||||
fn seed_is_rejected_in_prod_profile() {
|
||||
let err = ssw_platform::lowcode_seed::seed_gate(Profile::Prod)
|
||||
.expect_err("生产档必须拒绝跑低代码种子");
|
||||
assert!(err.contains("SSW_PROFILE"), "要说清用哪个环境变量:{err}");
|
||||
}
|
||||
|
||||
/// 🔴 开发档放行。
|
||||
#[test]
|
||||
fn seed_is_allowed_in_dev_profile() {
|
||||
assert!(ssw_platform::lowcode_seed::seed_gate(Profile::Dev).is_ok());
|
||||
}
|
||||
|
||||
/// 无参数 ⇒ **起服务**(不是退出码)。
|
||||
#[test]
|
||||
fn empty_args_mean_serve() {
|
||||
|
||||
@@ -1845,6 +1845,191 @@ impl NativeAdapter {
|
||||
));
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// 低代码动态 CRUD(P2-b)
|
||||
// ================================================================
|
||||
|
||||
/// 🔴 加载低代码功能并解析出(表单, 模型)。
|
||||
///
|
||||
/// `id` / `enCode` 二选一 —— 与 `form.validate` 同一套加载逻辑。
|
||||
async fn load_lowcode(
|
||||
&self,
|
||||
args: &Value,
|
||||
) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> {
|
||||
let row = self.load_visualdev(args).await?;
|
||||
|
||||
let form_text = row["formData"].as_str().unwrap_or("").trim().to_string();
|
||||
let tables_text = row["tablesData"].as_str().unwrap_or("").trim().to_string();
|
||||
|
||||
if form_text.is_empty() || tables_text.is_empty() {
|
||||
return Err(ToolError::new(
|
||||
"FORM_INCOMPLETE",
|
||||
"该功能缺少 f_form_data 或 f_tables_data,无法动态 CRUD",
|
||||
)
|
||||
.hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么"));
|
||||
}
|
||||
|
||||
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)
|
||||
.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")
|
||||
})?;
|
||||
|
||||
Ok((form, model))
|
||||
}
|
||||
|
||||
/// 🔴 取入参里的数据体(必须是对象)。
|
||||
fn record_payload(args: &Value) -> Result<Value, ToolError> {
|
||||
let data = args.get("data").cloned().unwrap_or_else(|| json!({}));
|
||||
if !data.is_object() {
|
||||
return Err(ToolError::new("BAD_ARG", "data 必须是对象").field("data"));
|
||||
}
|
||||
Ok(data)
|
||||
}
|
||||
|
||||
/// 🔴 `dryRun` 的默认值是 **true** —— 写工具先看再写。
|
||||
fn dry_run_flag(args: &Value) -> bool {
|
||||
args.get("dryRun")
|
||||
.and_then(Value::as_bool)
|
||||
.unwrap_or(true)
|
||||
}
|
||||
|
||||
/// 把执行结果整理成工具输出。
|
||||
fn crud_json(outcome: &crate::lowcode_crud::CrudOutcome) -> Value {
|
||||
let statements: Vec<Value> = outcome
|
||||
.sql
|
||||
.iter()
|
||||
.map(|s| {
|
||||
json!({
|
||||
"kind": s.kind_str(),
|
||||
"table": s.table,
|
||||
"sql": s.text,
|
||||
"params": s.params,
|
||||
"columns": s.param_columns,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
json!({
|
||||
"id": outcome.id,
|
||||
"dryRun": outcome.dry_run,
|
||||
"statements": outcome.statements,
|
||||
"sql": statements,
|
||||
"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?;
|
||||
let payload = Self::record_payload(args)?;
|
||||
let dry_run = Self::dry_run_flag(args);
|
||||
let now = crate::lowcode_crud::now_iso();
|
||||
|
||||
// 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`),
|
||||
// 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。
|
||||
let mut ctx = crate::lowcode_crud::build_context(
|
||||
None,
|
||||
Some(crate::lowcode_crud::DEFAULT_TENANT_ID),
|
||||
Some(&now),
|
||||
);
|
||||
|
||||
let outcome = crate::lowcode_crud::insert_record(
|
||||
&self.state.db,
|
||||
&form,
|
||||
&model,
|
||||
&payload,
|
||||
&mut ctx,
|
||||
dry_run,
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(Self::crud_json(&outcome))
|
||||
}
|
||||
|
||||
/// `data.record.update` —— 按设计稿更新一条记录(子表走差集对账)。
|
||||
async fn data_record_update(&self, args: &Value) -> Result<Value, ToolError> {
|
||||
let (form, model) = self.load_lowcode(args).await?;
|
||||
let payload = Self::record_payload(args)?;
|
||||
let dry_run = Self::dry_run_flag(args);
|
||||
let now = crate::lowcode_crud::now_iso();
|
||||
|
||||
let record_id = args
|
||||
.get("recordId")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string();
|
||||
if record_id.is_empty() {
|
||||
return Err(ToolError::new("MISSING_ARG", "recordId 不能为空")
|
||||
.field("recordId")
|
||||
.hint("先用 data.query 查到记录的 id"));
|
||||
}
|
||||
|
||||
// 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`),
|
||||
// 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。
|
||||
let mut ctx = crate::lowcode_crud::build_context(
|
||||
None,
|
||||
Some(crate::lowcode_crud::DEFAULT_TENANT_ID),
|
||||
Some(&now),
|
||||
);
|
||||
|
||||
let outcome = crate::lowcode_crud::update_record(
|
||||
&self.state.db,
|
||||
&form,
|
||||
&model,
|
||||
&payload,
|
||||
&mut ctx,
|
||||
&record_id,
|
||||
dry_run,
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(Self::crud_json(&outcome))
|
||||
}
|
||||
|
||||
/// `data.record.delete` —— 删一条记录(逻辑/物理按功能的 logicalDelete)。
|
||||
async fn data_record_delete(&self, args: &Value) -> Result<Value, ToolError> {
|
||||
let (form, model) = self.load_lowcode(args).await?;
|
||||
let dry_run = Self::dry_run_flag(args);
|
||||
let now = crate::lowcode_crud::now_iso();
|
||||
|
||||
let record_id = args
|
||||
.get("recordId")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string();
|
||||
if record_id.is_empty() {
|
||||
return Err(ToolError::new("MISSING_ARG", "recordId 不能为空")
|
||||
.field("recordId")
|
||||
.hint("先用 data.query 查到记录的 id"));
|
||||
}
|
||||
|
||||
// 🔴 单租户:租户值恒为 "0"(基线 `GlobalConst.DEFAULT_TENANT_VALUE`),
|
||||
// 但**仍然要写** `f_tenant_id` 列(Java `addTenantId()` 无条件执行)。
|
||||
let mut ctx = crate::lowcode_crud::build_context(
|
||||
None,
|
||||
Some(crate::lowcode_crud::DEFAULT_TENANT_ID),
|
||||
Some(&now),
|
||||
);
|
||||
|
||||
let outcome = crate::lowcode_crud::delete_record(
|
||||
&self.state.db,
|
||||
&form,
|
||||
&model,
|
||||
&mut ctx,
|
||||
&record_id,
|
||||
dry_run,
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(Self::crud_json(&outcome))
|
||||
}
|
||||
}
|
||||
|
||||
/// `form_err` —— 把 lowcode 的解析错误转成结构化工具错误。
|
||||
@@ -2175,6 +2360,11 @@ impl PlatformAdapter for NativeAdapter {
|
||||
"form.describe" => self.form_describe(&args).await,
|
||||
"form.validate" => self.form_validate(&args).await,
|
||||
|
||||
// ------------------------------------------------ 低代码动态 CRUD(P2-b,写)
|
||||
"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,
|
||||
|
||||
other => Err(ToolError::new(
|
||||
"OP_NOT_IMPLEMENTED",
|
||||
format!("原生适配器还没实现 op: {other}"),
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,752 @@
|
||||
//! lowcode_ddl 集成测试 —— **真实 pglite 库**上的「生成 DDL → 建表 → 回写模型 → 动态 CRUD」闭环。
|
||||
//!
|
||||
//! ## 🔴 为什么这是 P2-b 最关键的一组测试
|
||||
//!
|
||||
//! 前面各层分别证明:
|
||||
//!
|
||||
//! | 层 | 证明什么 |
|
||||
//! |---|---|
|
||||
//! | `sspf-lowcode` 的单测 | DDL 文本**长得对** |
|
||||
//! | `sspf-lowcode` 的 `real_ddl` | DDL 与**官方真实 DDL**同形 |
|
||||
//! | `lowcode_crud_it` | CRUD 在**手写的表**上能跑 |
|
||||
//!
|
||||
//! 但**没有任何一组**证明:「用生成器建的表」和「CRUD 用的模型」是**同一套**。
|
||||
//!
|
||||
//! 这一组补上最后一环:
|
||||
//!
|
||||
//! ```text
|
||||
//! 模型(fixture)
|
||||
//! ├─ plan_create() ──▶ CREATE TABLE ──▶ 真库建表
|
||||
//! ├─ rewrite_model() ▶ 回写后的模型(含系统列)
|
||||
//! └─ plan_insert() ──▶ INSERT ... ──▶ 真库写入(用回写后的模型)
|
||||
//! ```
|
||||
//!
|
||||
//! ## 🔴 这组测试能抓到的真实 bug(已经抓到过两个)
|
||||
//!
|
||||
//! | Bug | 现象 |
|
||||
//! |---|---|
|
||||
//! | `f_delete_mark` 写成 boolean | PG 报 `invalid input syntax for type integer: "true"` |
|
||||
//! | **建表后不回写模型** | 逻辑删除报 `LOGICAL_DELETE_UNSUPPORTED`(真实库明明有删除列) |
|
||||
//! | 主键不是复合的 | 生成器建的主键与 CRUD 假设的主键不一致 |
|
||||
//! | 子表外键列名不一致 | `column "f_receivableid" does not exist` |
|
||||
//! | 系统列重复追加 | `column "f_tenant_id" specified more than once` |
|
||||
//! | 类型映射错(decimal→text) | 数值列存成文本,排序错乱 |
|
||||
//!
|
||||
//! ## 🔴 pglite 是进程级单例 ⇒ 全文件串行 + 每测试专属表名
|
||||
//!
|
||||
//! 与 `lowcode_crud_it` 同款:`OnceCell` + 进程级 `Mutex`。
|
||||
//! **表名必须每个测试都不一样** —— 全文件共用一个库,
|
||||
//! 而且不同测试要不同的表结构(有的带删除列、有的不带)。
|
||||
|
||||
use serde_json::json;
|
||||
use sspf_lowcode::{plan_create, rewrite_model, DdlOptions, FormSchema, ModelSchema};
|
||||
use ssw_platform::lowcode_crud::{
|
||||
build_context, delete_record, insert_record, now_iso, DEFAULT_TENANT_ID,
|
||||
};
|
||||
use ssw_platform::platform::db::Db;
|
||||
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 临时库失败");
|
||||
db.ensure_schema().await.expect("ensure_schema 失败");
|
||||
db
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// 官方 fixture(与基线平台初始化 SQL 同源)
|
||||
// ============================================================
|
||||
|
||||
/// 生成一份带指定表名的官方模型。
|
||||
fn official_model(main: &str, sub: &str) -> String {
|
||||
format!(
|
||||
r#"[
|
||||
{{
|
||||
"table": "{main}", "tableName": "应收费用主表", "typeId": "1",
|
||||
"tableField": "", "relationField": "", "relationTable": "",
|
||||
"fields": [
|
||||
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
|
||||
{{ "field": "F_Building", "fieldName": "楼宇号", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Room", "fieldName": "房间号", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Company_name", "fieldName": "公司名称", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Sort_Code", "fieldName": "排序", "dataType": "bigint", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_EnabledMark", "fieldName": "有效标志", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_CreatorTime", "fieldName": "创建时间", "dataType": "datetime", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_CreatorUserId", "fieldName": "创建用户", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_LastModifyTime", "fieldName": "最后修改时间", "dataType": "datetime", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_LastModifyUserId", "fieldName": "最后修改用户", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "f_tenant_id", "fieldName": "租户id", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
|
||||
{{ "field": "f_version", "fieldName": "乐观锁", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "f_flow_task_id", "fieldName": "流程任务主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "f_flow_state", "fieldName": "流程任务状态", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }}
|
||||
]
|
||||
}},
|
||||
{{
|
||||
"table": "{sub}", "tableName": "应收费用明细表", "typeId": "0",
|
||||
"tableField": "F_Receivableid", "relationField": "F_Id", "relationTable": "{main}",
|
||||
"fields": [
|
||||
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
|
||||
{{ "field": "F_Receivableid", "fieldName": "主表id", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Month", "fieldName": "缴费月份", "dataType": "varchar", "dataLength": "200", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Rent", "fieldName": "房租", "dataType": "decimal", "dataLength": "18,2", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Totalbilling", "fieldName": "累计应收费用", "dataType": "decimal", "dataLength": "18,2", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_CreatorTime", "fieldName": "创建时间", "dataType": "datetime", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_CreatorUserId", "fieldName": "创建用户", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "f_tenant_id", "fieldName": "租户id", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }}
|
||||
]
|
||||
}}
|
||||
]"#
|
||||
)
|
||||
}
|
||||
|
||||
/// 生成一份带指定表名的表单。
|
||||
fn official_form(main: &str, sub: &str) -> String {
|
||||
format!(
|
||||
r#"{{
|
||||
"formRef": "formRef", "formModel": "formData",
|
||||
"primaryKeyPolicy": 1, "concurrencyLock": false, "logicalDelete": false,
|
||||
"fields": [
|
||||
{{ "__vModel__": "F_Building", "__config__": {{ "jnpfKey": "input", "label": "楼宇号", "layout": "colFormItem", "tableName": "{main}" }} }},
|
||||
{{ "__vModel__": "F_Room", "__config__": {{ "jnpfKey": "input", "label": "房间号", "layout": "colFormItem", "tableName": "{main}", "required": true }} }},
|
||||
{{ "__vModel__": "F_Company_name", "__config__": {{ "jnpfKey": "input", "label": "公司名称", "layout": "colFormItem", "tableName": "{main}" }} }},
|
||||
{{ "__vModel__": "tableField1", "__config__": {{ "jnpfKey": "table", "label": "添加明细", "layout": "rowFormItem", "tableName": "{sub}" }},
|
||||
"children": [
|
||||
{{ "__vModel__": "F_Month", "__config__": {{ "jnpfKey": "input", "label": "缴费月份", "layout": "colFormItem", "tableName": "{main}", "relationTable": "{sub}", "isSubTable": true, "parentVModel": "tableField1" }} }},
|
||||
{{ "__vModel__": "F_Rent", "__config__": {{ "jnpfKey": "inputNumber", "label": "房租", "layout": "colFormItem", "tableName": "{main}", "relationTable": "{sub}", "isSubTable": true, "parentVModel": "tableField1" }} }}
|
||||
]
|
||||
}}
|
||||
]
|
||||
}}"#
|
||||
)
|
||||
}
|
||||
|
||||
fn model_of(main: &str, sub: &str) -> ModelSchema {
|
||||
ModelSchema::from_str(&official_model(main, sub)).expect("模型应可解析")
|
||||
}
|
||||
|
||||
fn form_of(main: &str, sub: &str) -> FormSchema {
|
||||
FormSchema::from_str(&official_form(main, sub)).expect("表单应可解析")
|
||||
}
|
||||
|
||||
/// 逻辑删除的表单(`logicalDelete = true`)。
|
||||
fn logical_form_of(main: &str, sub: &str) -> FormSchema {
|
||||
let v: serde_json::Value = serde_json::from_str(&official_form(main, sub)).unwrap();
|
||||
let mut obj = v.as_object().unwrap().clone();
|
||||
obj.insert("logicalDelete".to_string(), serde_json::Value::Bool(true));
|
||||
FormSchema::parse(&serde_json::Value::Object(obj)).expect("表单应可解析")
|
||||
}
|
||||
|
||||
/// 房间号标唯一 + 逻辑删除的表单。
|
||||
fn unique_logical_form_of(main: &str, sub: &str) -> FormSchema {
|
||||
let mut v: serde_json::Value = serde_json::from_str(&official_form(main, sub)).unwrap();
|
||||
{
|
||||
let obj = v.as_object_mut().unwrap();
|
||||
obj.insert("logicalDelete".to_string(), serde_json::Value::Bool(true));
|
||||
obj.insert("useBusinessKey".to_string(), serde_json::Value::Bool(false));
|
||||
if let Some(fields) = obj.get_mut("fields").and_then(|f| f.as_array_mut()) {
|
||||
for f in fields.iter_mut() {
|
||||
let vm = f.get("__vModel__").and_then(|v| v.as_str()).unwrap_or("");
|
||||
if vm == "F_Room" {
|
||||
f.get_mut("__config__")
|
||||
.and_then(|c| c.as_object_mut())
|
||||
.unwrap()
|
||||
.insert("unique".to_string(), serde_json::Value::Bool(true));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
FormSchema::parse(&v).expect("表单应可解析")
|
||||
}
|
||||
|
||||
fn ctx() -> sspf_lowcode::WriteContext {
|
||||
let now = now_iso();
|
||||
let mut c = build_context(None, Some(DEFAULT_TENANT_ID), Some(&now));
|
||||
c.user_id = Some("u-1".to_string());
|
||||
c
|
||||
}
|
||||
|
||||
/// 🔴 用 DDL 生成器把表建出来,**并回写模型**(含系统列)。
|
||||
///
|
||||
/// ## 为什么必须回写
|
||||
///
|
||||
/// 基线平台 `VisualDevTableCre.tableList()` 建完表后会用**建表清单**
|
||||
/// 重新组装 `TableModel` 再写回 `f_tables_data` ⇒ 建表后的模型**含系统列**。
|
||||
///
|
||||
/// 不回写的后果(本项目已真实踩到):
|
||||
/// 逻辑删除报 `LOGICAL_DELETE_UNSUPPORTED` —— CRUD 层在**模型**里找
|
||||
/// `f_delete_mark`,找不到就报错,尽管真实库里明明有这一列。
|
||||
///
|
||||
/// ⇒ 返回**回写后的**模型,CRUD 用它跑 —— 这才是真实闭环。
|
||||
async fn create_tables(db: &Db, model: &ModelSchema, opts: &DdlOptions) -> ModelSchema {
|
||||
let plan = plan_create(model, opts).expect("应能生成建表计划");
|
||||
for sql in plan.render() {
|
||||
db.exec(&sql).await.unwrap_or_else(|e| panic!("建表失败: {e}\n{sql}"));
|
||||
}
|
||||
// 🔴 回写模型(建表后的真实表结构)。
|
||||
let rewritten = rewrite_model(model, &plan);
|
||||
ModelSchema::parse(&rewritten).expect("回写后的模型应可解析")
|
||||
}
|
||||
|
||||
/// 表是否已存在。
|
||||
async fn table_exists(db: &Db, table: &str) -> bool {
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT 1 AS \"x\" FROM information_schema.tables \
|
||||
WHERE table_name = $1 LIMIT 1",
|
||||
&[&table.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("查表失败");
|
||||
!rows.is_empty()
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ① 生成的 DDL 真能在 pglite 上建表
|
||||
// ============================================================
|
||||
|
||||
#[tokio::test]
|
||||
async fn generated_ddl_creates_real_tables() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let opts = DdlOptions::default_options();
|
||||
create_tables(
|
||||
db,
|
||||
&model_of("sspf_ddl_a_main", "sspf_ddl_a_sub"),
|
||||
&opts,
|
||||
)
|
||||
.await;
|
||||
|
||||
assert!(
|
||||
table_exists(db, "sspf_ddl_a_main").await,
|
||||
"主表应建出来"
|
||||
);
|
||||
assert!(
|
||||
table_exists(db, "sspf_ddl_a_sub").await,
|
||||
"子表应建出来"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 真实库里的列必须与生成器说的一致。
|
||||
#[tokio::test]
|
||||
async fn real_columns_match_generated_ddl() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let opts = DdlOptions::default_options();
|
||||
let model = model_of("sspf_ddl_b_main", "sspf_ddl_b_sub");
|
||||
create_tables(db, &model, &opts).await;
|
||||
|
||||
let plan = plan_create(&model, &opts).expect("应能生成建表计划");
|
||||
for t in plan.all() {
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT column_name AS \"name\" FROM information_schema.columns \
|
||||
WHERE table_name = $1 ORDER BY ordinal_position",
|
||||
&[&t.table],
|
||||
)
|
||||
.await
|
||||
.expect("查列失败");
|
||||
|
||||
let real: Vec<String> = rows
|
||||
.iter()
|
||||
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
|
||||
.collect();
|
||||
let expected = t.column_names();
|
||||
assert_eq!(
|
||||
real, expected,
|
||||
"🔴 表 {} 的真实列与生成器不一致",
|
||||
t.table
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// 🔴 主键必须是**复合**的 `(f_id, f_tenant_id)`。
|
||||
#[tokio::test]
|
||||
async fn real_primary_key_is_composite() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let opts = DdlOptions::default_options();
|
||||
create_tables(
|
||||
db,
|
||||
&model_of("sspf_ddl_c_main", "sspf_ddl_c_sub"),
|
||||
&opts,
|
||||
)
|
||||
.await;
|
||||
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT a.attname AS \"name\" \
|
||||
FROM pg_index i \
|
||||
JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) \
|
||||
WHERE i.indrelid = 'sspf_ddl_c_main'::regclass AND i.indisprimary \
|
||||
ORDER BY a.attnum",
|
||||
&[],
|
||||
)
|
||||
.await
|
||||
.expect("查主键失败");
|
||||
|
||||
let pks: Vec<String> = rows
|
||||
.iter()
|
||||
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
|
||||
.collect();
|
||||
assert_eq!(
|
||||
pks,
|
||||
vec!["f_id".to_string(), "f_tenant_id".to_string()],
|
||||
"🔴 官方真实 DDL 的主键是复合的 (f_id, f_tenant_id)"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 **回写后的模型**必须与真实库的列**完全一致**。
|
||||
///
|
||||
/// 这是「设计稿 ↔ 真实库」一致性的核心断言:
|
||||
/// 回写没做(或做错了)⇒ 模型少列 ⇒ 动态 CRUD 找不到删除列。
|
||||
#[tokio::test]
|
||||
async fn rewritten_model_matches_real_columns() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let mut opts = DdlOptions::default_options();
|
||||
opts.logical_delete = true;
|
||||
let model = model_of("sspf_ddl_k_main", "sspf_ddl_k_sub");
|
||||
let rewritten = create_tables(db, &model, &opts).await;
|
||||
|
||||
for t in rewritten.tables.iter() {
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT column_name AS \"name\" FROM information_schema.columns \
|
||||
WHERE table_name = $1 ORDER BY ordinal_position",
|
||||
&[&t.table],
|
||||
)
|
||||
.await
|
||||
.expect("查列失败");
|
||||
let real: Vec<String> = rows
|
||||
.iter()
|
||||
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
|
||||
.collect();
|
||||
assert_eq!(
|
||||
real,
|
||||
t.column_names(),
|
||||
"🔴 表 {} 的回写模型与真实库列不一致",
|
||||
t.table
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ② 用生成器建的表,跑真实 CRUD
|
||||
// ============================================================
|
||||
|
||||
/// 🔴 端到端:建表 → 回写模型 → 新增(主表 + 子表)→ 数据真落库。
|
||||
#[tokio::test]
|
||||
async fn crud_runs_on_generated_tables() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_d_main", "sspf_ddl_d_sub");
|
||||
let opts = DdlOptions::default_options();
|
||||
// 🔴 用**回写后的**模型跑 CRUD(真实闭环)。
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
let form = form_of(main, sub);
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form,
|
||||
&model,
|
||||
&json!({
|
||||
"F_Building": "A 栋",
|
||||
"F_Room": "A-101",
|
||||
"F_Company_name": "某某公司",
|
||||
"tableField1": [
|
||||
{ "F_Month": "2026-10", "F_Rent": 100.5 },
|
||||
{ "F_Month": "2026-11", "F_Rent": 200.25 }
|
||||
]
|
||||
}),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
assert_eq!(out.statements, 3, "1 主表 + 2 子表");
|
||||
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_room AS \"room\", f_company_name AS \"company\", \
|
||||
f_tenant_id AS \"tenant\" FROM sspf_ddl_d_main WHERE f_id = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查主表失败");
|
||||
assert_eq!(rows.len(), 1);
|
||||
assert_eq!(rows[0]["room"], json!("A-101"));
|
||||
assert_eq!(rows[0]["company"], json!("某某公司"));
|
||||
assert_eq!(rows[0]["tenant"], json!(DEFAULT_TENANT_ID));
|
||||
|
||||
// 子表外键列是 `f_receivableid`(**不是** `f_foreign_id`)
|
||||
let subs = db
|
||||
.query_json_params(
|
||||
"SELECT f_month AS \"month\", f_rent AS \"rent\", f_receivableid AS \"fk\" \
|
||||
FROM sspf_ddl_d_sub WHERE f_receivableid = $1 ORDER BY f_month",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查子表失败");
|
||||
assert_eq!(subs.len(), 2, "两条子表行都应落库: {subs:?}");
|
||||
assert_eq!(subs[0]["month"], json!("2026-10"));
|
||||
assert_eq!(subs[0]["rent"], json!(100.5));
|
||||
assert_eq!(subs[0]["fk"], json!(out.id.as_str()));
|
||||
}
|
||||
|
||||
/// 🔴 **decimal 列**必须真的存成数值(类型映射错 ⇒ 存成文本)。
|
||||
#[tokio::test]
|
||||
async fn decimal_columns_are_numeric_in_real_db() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_e_main", "sspf_ddl_e_sub");
|
||||
let opts = DdlOptions::default_options();
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
let form = form_of(main, sub);
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form,
|
||||
&model,
|
||||
&json!({
|
||||
"F_Room": "B-202",
|
||||
"tableField1": [ { "F_Month": "2026-10", "F_Rent": 1234.56 } ]
|
||||
}),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_rent AS \"rent\", pg_typeof(f_rent)::text AS \"typ\" \
|
||||
FROM sspf_ddl_e_sub WHERE f_receivableid = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查子表失败");
|
||||
assert_eq!(rows.len(), 1);
|
||||
assert_eq!(rows[0]["rent"], json!(1234.56), "数值应原样落库");
|
||||
assert_eq!(
|
||||
rows[0]["typ"],
|
||||
json!("numeric"),
|
||||
"🔴 decimal 列的 PG 类型应是 numeric(映射错就会变 text)"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 **datetime 列**必须真的存成 timestamp。
|
||||
///
|
||||
/// ## 🔴 注意:创建时间**不会被自动写**
|
||||
///
|
||||
/// 官方 fixture 表单里**没有** `createTime` 控件,Java 也是**按表单控件**写列
|
||||
/// (`FlowFormDataUtil.createMastTable()` 遍历 `mastForm`)。
|
||||
/// ⇒ `f_creatortime` 是「建表时按模型建的列」,但**运行时没人往里写**。
|
||||
///
|
||||
/// 这不是 bug,是官方形态:只有表单里放了 `createTime` 控件的设计稿才会自动填。
|
||||
/// 本测试验证的是**类型**(timestamp)以及「没控件就不写」这个口径。
|
||||
#[tokio::test]
|
||||
async fn datetime_columns_are_timestamp_in_real_db() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_f_main", "sspf_ddl_f_sub");
|
||||
let opts = DdlOptions::default_options();
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
let form = form_of(main, sub);
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form,
|
||||
&model,
|
||||
&json!({ "F_Room": "C-303" }),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT pg_typeof(f_creatortime)::text AS \"typ\", f_creatortime AS \"t\" \
|
||||
FROM sspf_ddl_f_main WHERE f_id = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查主表失败");
|
||||
assert_eq!(
|
||||
rows[0]["typ"],
|
||||
json!("timestamp without time zone"),
|
||||
"🔴 datetime 列的 PG 类型应是 timestamp"
|
||||
);
|
||||
assert!(
|
||||
rows[0]["t"].is_null(),
|
||||
"🔴 表单里没有 createTime 控件 ⇒ 创建时间不该被写(对齐 JNPF 的按控件写列)"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 表单里**有** `createTime` 控件 ⇒ 创建时间必须被自动写入。
|
||||
///
|
||||
/// 这与上一个测试互为对照:自动填充是**按控件**触发的,不是按列名。
|
||||
#[tokio::test]
|
||||
async fn create_time_is_filled_when_form_has_control() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_l_main", "sspf_ddl_l_sub");
|
||||
let opts = DdlOptions::default_options();
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
|
||||
// 表单里加一个 `createTime` 控件(`F_CreatorTime`)
|
||||
let mut v: serde_json::Value = serde_json::from_str(&official_form(main, sub)).unwrap();
|
||||
{
|
||||
let obj = v.as_object_mut().unwrap();
|
||||
let fields = obj.get_mut("fields").and_then(|f| f.as_array_mut()).unwrap();
|
||||
fields.push(json!({
|
||||
"__vModel__": "F_CreatorTime",
|
||||
"__config__": {
|
||||
"jnpfKey": "createTime", "label": "创建时间",
|
||||
"layout": "colFormItem", "tableName": main
|
||||
}
|
||||
}));
|
||||
}
|
||||
let form = FormSchema::parse(&v).expect("表单应可解析");
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form,
|
||||
&model,
|
||||
&json!({ "F_Room": "C-404" }),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_creatortime AS \"t\" FROM sspf_ddl_l_main WHERE f_id = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查主表失败");
|
||||
assert!(
|
||||
!rows[0]["t"].is_null(),
|
||||
"🔴 有 createTime 控件时创建时间必须被写入(AutoFill::Now)"
|
||||
);
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ③ 逻辑删除:🔴 抓 `f_delete_mark` 类型 bug 的那组测试
|
||||
// ============================================================
|
||||
|
||||
/// 🔴 逻辑删除必须成功,且删除标记是 **1**(INTEGER 列)。
|
||||
///
|
||||
/// ## 这组测试抓到的真实 bug
|
||||
///
|
||||
/// `f_delete_mark` 在官方真实 DDL 里是 `INTEGER`(Java `TableFeildsEnum.DELETEMARK`
|
||||
/// 的 dataType 也是 `"int"`),基线平台写的是 `equalTo(1)`。
|
||||
///
|
||||
/// 之前 Rust 侧写的是 `Value::Bool(true)` ⇒ 执行层转成字符串 `"true"`
|
||||
/// ⇒ PG 直接报 `invalid input syntax for type integer: "true"`。
|
||||
///
|
||||
/// ## 🔴 第二个真实 bug:不回写模型
|
||||
///
|
||||
/// 建表加了删除列,但**模型里没有** ⇒ CRUD 层找不到 `f_delete_mark`
|
||||
/// ⇒ 报 `LOGICAL_DELETE_UNSUPPORTED`。
|
||||
/// 解法是 `rewrite_model()`:建表后把真实表结构回写进模型。
|
||||
#[tokio::test]
|
||||
async fn logical_delete_writes_integer_marker() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_g_main", "sspf_ddl_g_sub");
|
||||
let mut opts = DdlOptions::default_options();
|
||||
opts.logical_delete = true;
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
let form = logical_form_of(main, sub);
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form,
|
||||
&model,
|
||||
&json!({
|
||||
"F_Room": "D-404",
|
||||
"tableField1": [ { "F_Month": "2026-10", "F_Rent": 100 } ]
|
||||
}),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
let mut c2 = ctx();
|
||||
delete_record(db, &form, &model, &mut c2, &out.id, false)
|
||||
.await
|
||||
.expect("🔴 逻辑删除应成功(写 integer 的删除标记)");
|
||||
|
||||
// 主表行还在,但删除标记 = 1
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_delete_mark AS \"mark\", f_delete_time AS \"time\", \
|
||||
f_delete_user_id AS \"user\" FROM sspf_ddl_g_main WHERE f_id = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查主表失败");
|
||||
assert_eq!(rows.len(), 1, "🔴 逻辑删除后行应还在表里");
|
||||
assert_eq!(
|
||||
rows[0]["mark"],
|
||||
json!(1),
|
||||
"🔴 删除标记应是 1(f_delete_mark 是 INTEGER,不是 boolean)"
|
||||
);
|
||||
assert!(!rows[0]["time"].is_null(), "删除时间应被写入");
|
||||
assert_eq!(rows[0]["user"], json!("u-1"), "删除人应被写入");
|
||||
|
||||
// 子表行也被逻辑删除
|
||||
let subs = db
|
||||
.query_json_params(
|
||||
"SELECT f_delete_mark AS \"mark\" FROM sspf_ddl_g_sub WHERE f_receivableid = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查子表失败");
|
||||
assert_eq!(subs.len(), 1);
|
||||
assert_eq!(subs[0]["mark"], json!(1), "子表也该被逻辑删除");
|
||||
}
|
||||
|
||||
/// 🔴 `logicalDelete = false` ⇒ **物理删除**(行真的消失)。
|
||||
#[tokio::test]
|
||||
async fn physical_delete_removes_rows_when_logical_is_off() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_h_main", "sspf_ddl_h_sub");
|
||||
let opts = DdlOptions::default_options();
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
let form = form_of(main, sub);
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form,
|
||||
&model,
|
||||
&json!({
|
||||
"F_Room": "E-505",
|
||||
"tableField1": [ { "F_Month": "2026-10", "F_Rent": 100 } ]
|
||||
}),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
let mut c2 = ctx();
|
||||
delete_record(db, &form, &model, &mut c2, &out.id, false)
|
||||
.await
|
||||
.expect("物理删除应成功");
|
||||
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_id FROM sspf_ddl_h_main WHERE f_id = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查主表失败");
|
||||
assert!(rows.is_empty(), "🔴 物理删除后主表行应消失");
|
||||
|
||||
let subs = db
|
||||
.query_json_params(
|
||||
"SELECT f_id FROM sspf_ddl_h_sub WHERE f_receivableid = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查子表失败");
|
||||
assert!(subs.is_empty(), "🔴 子表行也应消失(不能留孤儿)");
|
||||
}
|
||||
|
||||
/// 🔴 `logicalDelete = true` 但表里**没有**删除列 ⇒ 必须报错,不许静默物理删。
|
||||
///
|
||||
/// 这是「设计稿与真实库不一致」的典型:模型说逻辑删除,但表是按
|
||||
/// `logicalDelete = false` 建的。
|
||||
#[tokio::test]
|
||||
async fn logical_delete_on_table_without_marker_is_rejected() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_i_main", "sspf_ddl_i_sub");
|
||||
// 按 logicalDelete = false 建表(没有删除列)
|
||||
let opts = DdlOptions::default_options();
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
|
||||
let mut c = ctx();
|
||||
let out = insert_record(
|
||||
db,
|
||||
&form_of(main, sub),
|
||||
&model,
|
||||
&json!({ "F_Room": "F-606" }),
|
||||
&mut c,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("新增应成功");
|
||||
|
||||
let mut c2 = ctx();
|
||||
let err = delete_record(db, &logical_form_of(main, sub), &model, &mut c2, &out.id, false)
|
||||
.await
|
||||
.expect_err("🔴 表里没有删除列时,逻辑删除必须被拒");
|
||||
|
||||
assert_eq!(
|
||||
err.code, "LOGICAL_DELETE_UNSUPPORTED",
|
||||
"应报不支持逻辑删除: {}",
|
||||
err.message
|
||||
);
|
||||
|
||||
// 🔴 拒绝 ⇒ 行还在(不能被静默物理删)
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_id FROM sspf_ddl_i_main WHERE f_id = $1",
|
||||
&[&out.id],
|
||||
)
|
||||
.await
|
||||
.expect("查主表失败");
|
||||
assert_eq!(rows.len(), 1, "🔴 被拒的逻辑删除不该动数据");
|
||||
}
|
||||
|
||||
/// 🔴 逻辑删除的行**不参与**唯一性判重(对齐 Java 的 `delete_mark IS NULL`)。
|
||||
#[tokio::test]
|
||||
async fn logically_deleted_rows_do_not_block_unique_values() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_ddl_j_main", "sspf_ddl_j_sub");
|
||||
let mut opts = DdlOptions::default_options();
|
||||
opts.logical_delete = true;
|
||||
let model = create_tables(db, &model_of(main, sub), &opts).await;
|
||||
let form = unique_logical_form_of(main, sub);
|
||||
|
||||
// 第一条:房间号 UNI-1
|
||||
let mut c = ctx();
|
||||
let out = insert_record(db, &form, &model, &json!({ "F_Room": "UNI-1" }), &mut c, false)
|
||||
.await
|
||||
.expect("第一条应成功");
|
||||
|
||||
// 逻辑删除它
|
||||
let mut c2 = ctx();
|
||||
delete_record(db, &form, &model, &mut c2, &out.id, false)
|
||||
.await
|
||||
.expect("逻辑删除应成功");
|
||||
|
||||
// 再插入同房间号 ⇒ 应该**能**成功(已删的行不占坑)
|
||||
let mut c3 = ctx();
|
||||
insert_record(db, &form, &model, &json!({ "F_Room": "UNI-1" }), &mut c3, false)
|
||||
.await
|
||||
.expect("🔴 已逻辑删除的行不该再占着唯一值");
|
||||
}
|
||||
@@ -0,0 +1,366 @@
|
||||
//! 内核动态建表层的集成测试 —— **真实 pglite 库**。
|
||||
//!
|
||||
//! ## 覆盖什么
|
||||
//!
|
||||
//! | 测试 | 证明什么 |
|
||||
//! |---|---|
|
||||
//! | `create_tables_creates_real_tables` | 建表真的落到真实库 |
|
||||
//! | `create_tables_is_idempotent` | 重复建表不报错(幂等),且模型照样回写 |
|
||||
//! | `existing_table_with_different_columns_is_rejected` | 结构不符时报错,不硬改 |
|
||||
//! | `create_and_sync_writes_back_model` | `f_tables_data` 被回写成含系统列的模型 |
|
||||
//! | `model_after_write_back_matches_real_db` | 回写后的模型 ↔ 真实库列完全一致 |
|
||||
//! | `dry_run_creates_nothing` | dry-run 不建表不回写 |
|
||||
//! | `logical_delete_tables_get_delete_columns` | 逻辑删除 ⇒ 主表子表都有删除列 |
|
||||
//!
|
||||
//! ## 🔴 为什么单独一组
|
||||
//!
|
||||
//! `lowcode_ddl_it` 测的是 `sspf-lowcode` 的**纯计算**能力(DDL 文本 + 回写模型);
|
||||
//! 这一组测的是**内核执行层**:真连库、真建表、真回写 `base_visual_dev`。
|
||||
|
||||
use serde_json::{json, Value};
|
||||
use sspf_lowcode::{FormSchema, ModelSchema};
|
||||
use ssw_platform::lowcode_ddl::{
|
||||
create_and_sync, create_tables, preview_ddl, real_columns, table_exists, write_back_model,
|
||||
};
|
||||
use ssw_platform::platform::db::Db;
|
||||
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 临时库失败");
|
||||
db.ensure_schema().await.expect("ensure_schema 失败");
|
||||
db
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// 一份带指定表名的模型。
|
||||
fn model_json(main: &str, sub: &str) -> String {
|
||||
format!(
|
||||
r#"[
|
||||
{{
|
||||
"table": "{main}", "tableName": "主表", "typeId": "1",
|
||||
"tableField": "", "relationField": "", "relationTable": "",
|
||||
"fields": [
|
||||
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
|
||||
{{ "field": "F_Room", "fieldName": "房间号", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }}
|
||||
]
|
||||
}},
|
||||
{{
|
||||
"table": "{sub}", "tableName": "子表", "typeId": "0",
|
||||
"tableField": "F_Receivableid", "relationField": "F_Id", "relationTable": "{main}",
|
||||
"fields": [
|
||||
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
|
||||
{{ "field": "F_Receivableid", "fieldName": "主表id", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
|
||||
{{ "field": "F_Month", "fieldName": "缴费月份", "dataType": "varchar", "dataLength": "200", "primaryKey": 0, "allowNull": 1 }}
|
||||
]
|
||||
}}
|
||||
]"#
|
||||
)
|
||||
}
|
||||
|
||||
/// 一份带指定表名的表单。
|
||||
fn form_json(main: &str, sub: &str, logical_delete: bool) -> String {
|
||||
format!(
|
||||
r#"{{
|
||||
"formRef": "formRef", "formModel": "formData",
|
||||
"primaryKeyPolicy": 1, "concurrencyLock": false, "logicalDelete": {logical_delete},
|
||||
"fields": [
|
||||
{{ "__vModel__": "F_Room", "__config__": {{ "jnpfKey": "input", "label": "房间号", "layout": "colFormItem", "tableName": "{main}" }} }},
|
||||
{{ "__vModel__": "tableField1", "__config__": {{ "jnpfKey": "table", "label": "添加明细", "layout": "rowFormItem", "tableName": "{sub}" }},
|
||||
"children": [
|
||||
{{ "__vModel__": "F_Month", "__config__": {{ "jnpfKey": "input", "label": "缴费月份", "layout": "colFormItem", "tableName": "{main}", "relationTable": "{sub}", "isSubTable": true, "parentVModel": "tableField1" }} }}
|
||||
]
|
||||
}}
|
||||
]
|
||||
}}"#
|
||||
)
|
||||
}
|
||||
|
||||
fn model_of(main: &str, sub: &str) -> ModelSchema {
|
||||
ModelSchema::from_str(&model_json(main, sub)).expect("模型应可解析")
|
||||
}
|
||||
|
||||
fn form_of(main: &str, sub: &str, logical_delete: bool) -> FormSchema {
|
||||
FormSchema::from_str(&form_json(main, sub, logical_delete)).expect("表单应可解析")
|
||||
}
|
||||
|
||||
/// 🔴 往 `base_visual_dev` 插一条功能定义(回写的目标)。
|
||||
async fn insert_visualdev(db: &Db, id: &str, en_code: &str, tables_data: &str) {
|
||||
db.exec_params(
|
||||
"INSERT INTO base_visual_dev \
|
||||
(f_id, f_full_name, f_en_code, f_state, f_type, f_tables_data, f_form_data, f_column_data, f_tenant_id) \
|
||||
VALUES ($1, $2, $3, 1, 1, $4, '', '', '0')",
|
||||
&[
|
||||
&id.to_string(),
|
||||
&format!("{en_code} 功能"),
|
||||
&en_code.to_string(),
|
||||
&tables_data.to_string(),
|
||||
],
|
||||
)
|
||||
.await
|
||||
.expect("插 base_visual_dev 失败");
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ① 建表真的落到真实库
|
||||
// ============================================================
|
||||
|
||||
#[tokio::test]
|
||||
async fn create_tables_creates_real_tables() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_a_main", "sspf_k_ddl_a_sub");
|
||||
|
||||
let out = create_tables(db, &model_of(main, sub), &form_of(main, sub, false), false)
|
||||
.await
|
||||
.expect("建表应成功");
|
||||
|
||||
assert_eq!(out.tables.len(), 2, "主表 + 子表");
|
||||
assert!(out.skipped.is_empty());
|
||||
assert!(table_exists(db, main).await.unwrap(), "主表应建出来");
|
||||
assert!(table_exists(db, sub).await.unwrap(), "子表应建出来");
|
||||
|
||||
// DDL 应含复合主键
|
||||
assert!(out.ddl[0].contains("PRIMARY KEY (f_id, f_tenant_id)"), "{}", out.ddl[0]);
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ② 幂等
|
||||
// ============================================================
|
||||
|
||||
/// 🔴 重复建表**不报错**(基线平台同款:`DbTableServiceImpl.createTable()` 存在就返回)。
|
||||
#[tokio::test]
|
||||
async fn create_tables_is_idempotent() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_b_main", "sspf_k_ddl_b_sub");
|
||||
let model = model_of(main, sub);
|
||||
let form = form_of(main, sub, false);
|
||||
|
||||
let first = create_tables(db, &model, &form, false).await.expect("首次建表");
|
||||
assert_eq!(first.tables.len(), 2);
|
||||
assert!(first.skipped.is_empty());
|
||||
|
||||
// 第二次 ⇒ 全部跳过,不报错
|
||||
let second = create_tables(db, &model, &form, false)
|
||||
.await
|
||||
.expect("🔴 重复建表不该报错(幂等)");
|
||||
assert!(second.tables.is_empty(), "第二次不该再建表");
|
||||
assert_eq!(second.skipped.len(), 2, "两张表都该被跳过");
|
||||
assert!(!second.notes.is_empty(), "该说明为什么跳过");
|
||||
}
|
||||
|
||||
/// 🔴 表已存在但**列结构不同** ⇒ 报错,不硬改。
|
||||
#[tokio::test]
|
||||
async fn existing_table_with_different_columns_is_rejected() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_c_main", "sspf_k_ddl_c_sub");
|
||||
|
||||
// 先手建一张**列不一样**的表
|
||||
db.exec(&format!(
|
||||
"CREATE TABLE {main} (f_id VARCHAR(50) NOT NULL, f_other VARCHAR(10))"
|
||||
))
|
||||
.await
|
||||
.expect("手建表失败");
|
||||
|
||||
let err = create_tables(db, &model_of(main, sub), &form_of(main, sub, false), false)
|
||||
.await
|
||||
.expect_err("🔴 结构不符必须报错");
|
||||
|
||||
assert_eq!(
|
||||
err.code, "TABLE_EXISTS_DIFFERENT",
|
||||
"应报结构不一致: {}",
|
||||
err.message
|
||||
);
|
||||
// 错误要说清差在哪
|
||||
assert!(err.message.contains("f_tenant_id"), "应指出缺哪列: {}", err.message);
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ③ 回写 `f_tables_data`
|
||||
// ============================================================
|
||||
|
||||
/// 🔴 建表 + 回写:`base_visual_dev.f_tables_data` 要变成**含系统列**的模型。
|
||||
#[tokio::test]
|
||||
async fn create_and_sync_writes_back_model() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_d_main", "sspf_k_ddl_d_sub");
|
||||
let id = "vd_ddl_d";
|
||||
|
||||
insert_visualdev(db, id, "demoDdlD", &model_json(main, sub)).await;
|
||||
|
||||
let out = create_and_sync(
|
||||
db,
|
||||
id,
|
||||
&model_of(main, sub),
|
||||
&form_of(main, sub, false),
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("建表+回写应成功");
|
||||
|
||||
// 读回 `f_tables_data`
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT COALESCE(f_tables_data,'') AS \"tablesData\" FROM base_visual_dev WHERE f_id = $1",
|
||||
&[&id.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("读 base_visual_dev 失败");
|
||||
let text = rows[0]["tablesData"].as_str().unwrap_or_default();
|
||||
assert!(!text.is_empty(), "回写后不该是空");
|
||||
|
||||
// 回写的模型应含系统列
|
||||
let parsed: Value = serde_json::from_str(text).expect("回写内容应是合法 JSON");
|
||||
let m = ModelSchema::parse(&parsed).expect("回写内容应是合法模型");
|
||||
let names = m.main_table().unwrap().column_names();
|
||||
for want in ["f_id", "f_tenant_id", "f_version", "f_flow_state"] {
|
||||
assert!(names.contains(&want.to_string()), "回写后模型缺 {want}: {names:?}");
|
||||
}
|
||||
|
||||
// 回写的内容与返回值一致
|
||||
assert_eq!(parsed, out.model);
|
||||
}
|
||||
|
||||
/// 🔴 回写后的模型 ↔ 真实库列**完全一致**。
|
||||
#[tokio::test]
|
||||
async fn model_after_write_back_matches_real_db() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_e_main", "sspf_k_ddl_e_sub");
|
||||
let id = "vd_ddl_e";
|
||||
|
||||
insert_visualdev(db, id, "demoDdlE", &model_json(main, sub)).await;
|
||||
|
||||
let out = create_and_sync(
|
||||
db,
|
||||
id,
|
||||
&model_of(main, sub),
|
||||
&form_of(main, sub, false),
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("建表+回写应成功");
|
||||
|
||||
let m = ModelSchema::parse(&out.model).expect("回写模型应可解析");
|
||||
for t in m.tables.iter() {
|
||||
let real = real_columns(db, &t.table).await.unwrap();
|
||||
assert_eq!(
|
||||
real,
|
||||
t.column_names(),
|
||||
"🔴 表 {} 的回写模型与真实库列不一致",
|
||||
t.table
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// 🔴 逻辑删除 ⇒ 主表与子表**都**有删除列(回写后)。
|
||||
#[tokio::test]
|
||||
async fn logical_delete_tables_get_delete_columns() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_f_main", "sspf_k_ddl_f_sub");
|
||||
|
||||
let out = create_tables(db, &model_of(main, sub), &form_of(main, sub, true), false)
|
||||
.await
|
||||
.expect("建表应成功");
|
||||
|
||||
let m = ModelSchema::parse(&out.model).expect("回写模型应可解析");
|
||||
for t in m.tables.iter() {
|
||||
let names = t.column_names();
|
||||
for want in ["f_delete_mark", "f_delete_time", "f_delete_user_id"] {
|
||||
assert!(
|
||||
names.contains(&want.to_string()),
|
||||
"表 {} 缺 {want}: {names:?}",
|
||||
t.table
|
||||
);
|
||||
}
|
||||
// 🔴 删除标记在真实库里也是 INTEGER
|
||||
let real = real_columns(db, &t.table).await.unwrap();
|
||||
assert!(real.contains(&"f_delete_mark".to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ④ dry-run
|
||||
// ============================================================
|
||||
|
||||
/// 🔴 dry-run:不建表、不回写,但**给出** DDL 与回写后的模型。
|
||||
#[tokio::test]
|
||||
async fn dry_run_creates_nothing() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
let (main, sub) = ("sspf_k_ddl_g_main", "sspf_k_ddl_g_sub");
|
||||
let id = "vd_ddl_g";
|
||||
|
||||
insert_visualdev(db, id, "demoDdlG", &model_json(main, sub)).await;
|
||||
|
||||
let out = create_and_sync(
|
||||
db,
|
||||
id,
|
||||
&model_of(main, sub),
|
||||
&form_of(main, sub, false),
|
||||
true,
|
||||
)
|
||||
.await
|
||||
.expect("dry-run 应成功");
|
||||
|
||||
assert!(out.dry_run);
|
||||
assert_eq!(out.tables.len(), 2, "dry-run 也要报出会建哪几张表");
|
||||
assert!(!out.ddl.is_empty(), "dry-run 要给出 DDL");
|
||||
|
||||
// 🔴 没建表
|
||||
assert!(
|
||||
!table_exists(db, main).await.unwrap(),
|
||||
"dry-run 不该建表"
|
||||
);
|
||||
|
||||
// 🔴 没回写
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT COALESCE(f_tables_data,'') AS \"tablesData\" FROM base_visual_dev WHERE f_id = $1",
|
||||
&[&id.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("读 base_visual_dev 失败");
|
||||
assert_eq!(
|
||||
rows[0]["tablesData"].as_str().unwrap_or_default(),
|
||||
model_json(main, sub),
|
||||
"🔴 dry-run 不该回写模型"
|
||||
);
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// ⑤ 回写的边界
|
||||
// ============================================================
|
||||
|
||||
/// 🔴 回写到不存在的功能 ⇒ 报 `FORM_NOT_FOUND`。
|
||||
#[tokio::test]
|
||||
async fn write_back_to_missing_visualdev_is_rejected() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
|
||||
let err = write_back_model(db, "no-such-id", &json!([]))
|
||||
.await
|
||||
.expect_err("回写到不存在的功能必须报错");
|
||||
assert_eq!(err.code, "FORM_NOT_FOUND");
|
||||
}
|
||||
|
||||
/// 🔴 DDL 预览不碰数据库。
|
||||
#[tokio::test]
|
||||
async fn preview_ddl_needs_no_database() {
|
||||
let (main, sub) = ("sspf_k_ddl_h_main", "sspf_k_ddl_h_sub");
|
||||
let ddl = preview_ddl(&model_of(main, sub), &form_of(main, sub, false)).expect("预览应成功");
|
||||
assert_eq!(ddl.len(), 2);
|
||||
assert!(ddl[0].contains("CREATE TABLE sspf_k_ddl_h_main"));
|
||||
assert!(ddl[1].contains("CREATE TABLE sspf_k_ddl_h_sub"));
|
||||
}
|
||||
@@ -0,0 +1,309 @@
|
||||
//! 开发期低代码种子的集成测试 —— **真实 pglite 库**。
|
||||
//!
|
||||
//! ## 覆盖什么
|
||||
//!
|
||||
//! | 测试 | 证明什么 |
|
||||
//! |---|---|
|
||||
//! | `preview_needs_no_database` | 演练**连库都不开**(只读 fixture + 算 DDL) |
|
||||
//! | `seed_creates_real_tables` | 种子真的建出 `test_receivable` / `test_details` |
|
||||
//! | `seed_writes_visual_dev_and_release` | `base_visual_dev` 与 `base_visual_release` 各有一行 |
|
||||
//! | `seed_write_back_includes_system_columns` | 回写后的模型含平台系统列(`f_tenant_id` 等) |
|
||||
//! | `seed_is_idempotent` | 重复跑不报错、不重复行 |
|
||||
//! | `seeded_feature_supports_record_insert` | 种完的功能够用 `data.record.insert` 写数据 |
|
||||
//! | `seeded_feature_matches_official_ddl` | 建出来的列与**官方真实 DDL** 逐列一致 |
|
||||
//!
|
||||
//! ## 🔴 为什么最后两条最重要
|
||||
//!
|
||||
//! 种子的目的不是「库里有行」,而是「**种出来的东西能用**」:
|
||||
//! - `seeded_feature_supports_record_insert` ⇒ 端到端闭环(种子 → 写工具 → 真落库);
|
||||
//! - `seeded_feature_matches_official_ddl` ⇒ 列名/类型/顺序与基线平台**一致**
|
||||
//! (不一致 ⇒ 迁移期跨库读写直接炸)。
|
||||
|
||||
use serde_json::Value;
|
||||
use ssw_platform::lowcode_crud::{build_context, insert_record, now_iso, DEFAULT_TENANT_ID};
|
||||
use ssw_platform::lowcode_ddl::real_columns;
|
||||
use ssw_platform::lowcode_seed::{
|
||||
fixture_path, preview_lowcode_demo, seed_lowcode_demo, DEMO_EN_CODE, DEMO_ID,
|
||||
};
|
||||
use ssw_platform::platform::db::Db;
|
||||
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 临时库失败");
|
||||
db.ensure_schema().await.expect("ensure_schema 失败");
|
||||
db
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// 项目根(测试的 cwd = crate 目录 ⇒ 上溯两级到仓库根)。
|
||||
fn project_dir() -> std::path::PathBuf {
|
||||
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.parent()
|
||||
.and_then(|p| p.parent())
|
||||
.expect("应能定位到项目根")
|
||||
.to_path_buf()
|
||||
}
|
||||
|
||||
/// 官方 fixture 的真实路径(供断言用)。
|
||||
fn fixture(name: &str) -> std::path::PathBuf {
|
||||
fixture_path(&project_dir(), name)
|
||||
}
|
||||
|
||||
/// 🔴 演练:**连库都不开**。
|
||||
#[tokio::test]
|
||||
async fn preview_needs_no_database() {
|
||||
// 🔴 刻意**不**取共享库 ⇒ 如果演练偷偷开了库,这里会撞 pglite 的
|
||||
// 「一个进程只能开一个实例」限制(后面那些测试会开库)⇒ 立刻暴露。
|
||||
let outcome = preview_lowcode_demo(&project_dir()).expect("演练应成功");
|
||||
assert!(outcome.dry_run, "演练必须标 dry_run");
|
||||
assert_eq!(
|
||||
outcome.tables,
|
||||
vec!["test_receivable".to_string(), "test_details".to_string()],
|
||||
"演练要报出要建的两张表"
|
||||
);
|
||||
assert!(!outcome.ddl.is_empty(), "演练要给出 DDL");
|
||||
assert!(outcome.ddl[0].contains("CREATE TABLE test_receivable"));
|
||||
}
|
||||
|
||||
/// 🔴 种子真的建出物理表 + 两行功能定义。
|
||||
#[tokio::test]
|
||||
async fn seed_creates_real_tables() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
|
||||
let outcome = seed_lowcode_demo(db, &project_dir())
|
||||
.await
|
||||
.expect("种子应成功");
|
||||
|
||||
assert!(!outcome.dry_run);
|
||||
assert_eq!(outcome.form_id, DEMO_ID);
|
||||
assert_eq!(outcome.en_code, DEMO_EN_CODE);
|
||||
|
||||
// ---- 两张表真的在库里 ----
|
||||
for table in ["test_receivable", "test_details"] {
|
||||
let cols = real_columns(db, table)
|
||||
.await
|
||||
.unwrap_or_else(|e| panic!("表 {table} 应该建出来了: {} {}", e.code, e.message));
|
||||
assert!(!cols.is_empty(), "表 {table} 应该是有列的");
|
||||
}
|
||||
|
||||
// ---- 功能定义两行都在 ----
|
||||
for table in ["base_visual_dev", "base_visual_release"] {
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
&format!("SELECT f_id AS \"id\" FROM {table} WHERE f_id = $1 LIMIT 1"),
|
||||
&[&DEMO_ID.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("查功能定义");
|
||||
assert_eq!(rows.len(), 1, "{table} 里应有且只有一行示例功能");
|
||||
}
|
||||
}
|
||||
|
||||
/// 🔴 回写后的模型含**平台系统列**(`f_tenant_id` / `f_version` …)。
|
||||
///
|
||||
/// 这是「建表后回写」机制的价值所在:不回写 ⇒ CRUD 层找不到 `f_delete_mark`
|
||||
/// ⇒ 逻辑删除直接报 `LOGICAL_DELETE_UNSUPPORTED`。
|
||||
#[tokio::test]
|
||||
async fn seed_write_back_includes_system_columns() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
|
||||
let outcome = seed_lowcode_demo(db, &project_dir())
|
||||
.await
|
||||
.expect("种子应成功");
|
||||
|
||||
let main = outcome.model[0].clone();
|
||||
let fields = main["fields"].as_array().expect("fields 应是数组");
|
||||
let names: Vec<&str> = fields
|
||||
.iter()
|
||||
.filter_map(|f| f["field"].as_str())
|
||||
.collect();
|
||||
|
||||
for want in [
|
||||
"f_tenant_id",
|
||||
"f_version",
|
||||
"f_flow_id",
|
||||
"f_flow_task_id",
|
||||
"f_flow_state",
|
||||
] {
|
||||
assert!(
|
||||
names.contains(&want),
|
||||
"回写后的模型应含系统列 {want},实际:{names:?}"
|
||||
);
|
||||
}
|
||||
|
||||
// ---- 库里那一行的 f_tables_data 也要是回写后的 ----
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_tables_data AS \"tables\" FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
|
||||
&[&DEMO_ID.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("读回写的模型");
|
||||
let text = rows[0]["tables"].as_str().unwrap_or("");
|
||||
let stored: Value = serde_json::from_str(text).expect("回写的模型应是合法 JSON");
|
||||
assert_eq!(
|
||||
stored, outcome.model,
|
||||
"库里存的模型必须与回写产出逐字一致"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 **幂等**:重复跑不报错、不重复行。
|
||||
#[tokio::test]
|
||||
async fn seed_is_idempotent() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
|
||||
// 第一跑(可能已被前面的测试种过 ⇒ 也应是幂等的)。
|
||||
seed_lowcode_demo(db, &project_dir()).await.expect("第一次种子");
|
||||
// 第二跑 ⇒ 表已存在 ⇒ 跳过建表,但**仍回写模型**。
|
||||
let second = seed_lowcode_demo(db, &project_dir())
|
||||
.await
|
||||
.expect("第二次种子也必须成功(幂等)");
|
||||
|
||||
assert!(
|
||||
second.tables.is_empty(),
|
||||
"第二次不该再建表(已存在)"
|
||||
);
|
||||
assert_eq!(
|
||||
second.skipped,
|
||||
vec!["test_receivable".to_string(), "test_details".to_string()],
|
||||
"第二次应把两张表记为「已存在」"
|
||||
);
|
||||
|
||||
// 功能定义仍只有一行。
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_id AS \"id\" FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
|
||||
&[&DEMO_ID.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("查功能定义");
|
||||
assert_eq!(rows.len(), 1, "重复跑不许留下重复行");
|
||||
}
|
||||
|
||||
/// 🔴 **种完的功能够用** —— 端到端闭环。
|
||||
#[tokio::test]
|
||||
async fn seeded_feature_supports_record_insert() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
|
||||
seed_lowcode_demo(db, &project_dir()).await.expect("种子");
|
||||
|
||||
// ---- 从库里读回功能定义(模拟 MCP 的 `load_visualdev`)----
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_form_data AS \"formData\", f_tables_data AS \"tablesData\" \
|
||||
FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
|
||||
&[&DEMO_ID.to_string()],
|
||||
)
|
||||
.await
|
||||
.expect("读功能定义");
|
||||
assert_eq!(rows.len(), 1);
|
||||
|
||||
let form = sspf_lowcode::FormSchema::from_str(rows[0]["formData"].as_str().unwrap_or(""))
|
||||
.expect("表单应可解析");
|
||||
let model = sspf_lowcode::ModelSchema::from_str(rows[0]["tablesData"].as_str().unwrap_or(""))
|
||||
.expect("模型应可解析");
|
||||
|
||||
// ---- 走真正的写入路径(与 MCP `data.record.insert` 同款)----
|
||||
let payload = serde_json::json!({ "F_Room": "A-101", "F_Company_name": "某某公司" });
|
||||
let now = now_iso();
|
||||
let mut ctx = build_context(None, Some(DEFAULT_TENANT_ID), Some(&now));
|
||||
|
||||
let outcome = insert_record(db, &form, &model, &payload, &mut ctx, false)
|
||||
.await
|
||||
.expect("种完的功应该能写数据");
|
||||
|
||||
assert!(!outcome.id.is_empty(), "应返回记录 id");
|
||||
|
||||
// ---- 真落库了 ----
|
||||
let rows = db
|
||||
.query_json_params(
|
||||
"SELECT f_room AS \"room\", f_tenant_id AS \"tenant\" \
|
||||
FROM test_receivable WHERE f_id = $1 LIMIT 1",
|
||||
&[&outcome.id],
|
||||
)
|
||||
.await
|
||||
.expect("查刚写的记录");
|
||||
assert_eq!(rows.len(), 1, "记录应真的在库里");
|
||||
assert_eq!(rows[0]["room"].as_str(), Some("A-101"));
|
||||
// 🔴 单租户口径:租户列**必须**被写(Java `addTenantId()` 无条件执行),
|
||||
// 且值恒为 "0"(`GlobalConst.DEFAULT_TENANT_VALUE`)。
|
||||
assert_eq!(
|
||||
rows[0]["tenant"].as_str(),
|
||||
Some("0"),
|
||||
"单租户下 f_tenant_id 必须写 \"0\""
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 建出来的列与**官方真实 DDL** 逐列一致。
|
||||
///
|
||||
/// 官方(`jnpf_dbnull_init.sql` 的 `CREATE TABLE test_receivable`)的列序:
|
||||
/// ```text
|
||||
/// f_id, f_building, f_room, f_company_name, f_userid, f_phone, f_ost,
|
||||
/// f_sort_code, f_enabledmark, f_creatortime, f_creatoruserid,
|
||||
/// f_lastmodifytime, f_lastmodifyuserid, f_tenant_id, f_version,
|
||||
/// f_flowtaskid, f_flow_id, f_flow_task_id, f_inte_assistant, f_flow_state
|
||||
/// ```
|
||||
#[tokio::test]
|
||||
async fn seeded_feature_matches_official_ddl() {
|
||||
let _g = LOCK.lock().await;
|
||||
let db = db().await;
|
||||
|
||||
seed_lowcode_demo(db, &project_dir()).await.expect("种子");
|
||||
|
||||
let cols = real_columns(db, "test_receivable")
|
||||
.await
|
||||
.expect("读列");
|
||||
|
||||
let expected = [
|
||||
"f_id",
|
||||
"f_building",
|
||||
"f_room",
|
||||
"f_company_name",
|
||||
"f_userid",
|
||||
"f_phone",
|
||||
"f_ost",
|
||||
"f_sort_code",
|
||||
"f_enabledmark",
|
||||
"f_creatortime",
|
||||
"f_creatoruserid",
|
||||
"f_lastmodifytime",
|
||||
"f_lastmodifyuserid",
|
||||
"f_tenant_id",
|
||||
"f_version",
|
||||
"f_flowtaskid",
|
||||
"f_flow_id",
|
||||
"f_flow_task_id",
|
||||
"f_inte_assistant",
|
||||
"f_flow_state",
|
||||
];
|
||||
|
||||
assert_eq!(
|
||||
cols,
|
||||
expected.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
|
||||
"🔴 建出来的列必须与官方真实 DDL 逐列一致(列名 + 顺序)"
|
||||
);
|
||||
}
|
||||
|
||||
/// 🔴 fixture 必须在(种子依赖它 ⇒ 路径错了要立刻报,不是静默跳过)。
|
||||
#[test]
|
||||
fn official_fixtures_exist() {
|
||||
for name in [
|
||||
"crates/sspf-lowcode/tests/fixtures/sample_form.json",
|
||||
"crates/sspf-lowcode/tests/fixtures/sample_model.json",
|
||||
] {
|
||||
let p = fixture(name);
|
||||
assert!(p.is_file(), "官方 fixture 必须存在:{}", p.display());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user