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:
admin committed 2026-10-31 19:26:47 +08:00
1 parent 343772be42
commit bcbe46c92b
23 files changed
+11185 -26

No files matched your search

+304
View File
@@ -0,0 +1,304 @@
//! real_ddl —— 用**官方初始化数据里的真模型**验证建表 DDL 生成。
//!
//! ## 为什么必须用真数据
//!
//! `ddl.rs` 的单测用**合成**模型验证规则;这份用**官方 fixture**
//! (`tests/fixtures/sample_model.json`,与基线平台初始化 SQL 同源)验证
//! 「生成的 DDL 与官方真实 DDL 同形」。
//!
//! ## 🔴 这份测试钉死的三件事
//!
//! | 真相 | 影响 |
//! |---|---|
//! | 官方真实 DDL 的主键是**复合**的 `(f_id, f_tenant_id)` | 单列主键 ⇒ 与基线库结构不一致,跨库读写直接炸 |
//! | 子表外键列是 `f_receivableid`(**不是** `f_foreign_id`) | 硬编码 ⇒ `column does not exist` |
//! | 官方模型里**已含**系统列(`f_tenant_id` / `f_version` / …) | 重复追加 ⇒ 建表报 duplicate column |
//!
//! ## 🔴 断言的强度
//!
//! [`ddl_matches_official_ddl_line_by_line`]:把生成的 DDL **逐列**与官方
//! `jnpf_db_init.sql` 里的 `CREATE TABLE test_receivable` 对照 ——
//! 列名、类型、顺序、NOT NULL、DEFAULT 全部要一致。
//!
//! 这不是「差不多就行」的断言:任何一列对不上就红。
use std::path::PathBuf;
use sspf_lowcode::{plan_create, DdlOptions, ModelSchema};
fn fixture(name: &str) -> String {
let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
p.push("tests/fixtures");
p.push(name);
std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("读不到 {}: {e}", p.display()))
}
fn real_model() -> ModelSchema {
let raw = fixture("sample_model.json");
ModelSchema::parse(&serde_json::from_str(&raw).unwrap()).unwrap()
}
fn opts() -> DdlOptions {
DdlOptions::default_options()
}
/// 从 `CREATE TABLE` 文本里抽出「列名 ⇒ 完整定义」。
fn column_defs(sql: &str) -> Vec<(String, String)> {
let body = sql
.split_once("(\n")
.expect("应有 CREATE TABLE (")
.1
.rsplit_once("\n);")
.expect("应有 );")
.0;
body.lines()
.filter_map(|l| {
let l = l.trim().trim_end_matches(',').trim();
if l.is_empty() || l.starts_with("PRIMARY KEY") {
return None;
}
let (name, rest) = l.split_once(' ')?;
Some((name.to_string(), rest.to_string()))
})
.collect()
}
/// 🔴 生成的 DDL 必须与官方真实 DDL **逐列一致**。
///
/// 官方 `jnpf_db_init.sql`(PostgreSQL 版):
/// ```sql
/// CREATE TABLE test_receivable (
/// f_id VARCHAR(50) NOT NULL,
/// f_building VARCHAR(100),
/// f_room VARCHAR(100),
/// f_company_name VARCHAR(50),
/// f_userid VARCHAR(50),
/// f_phone VARCHAR(50),
/// f_ost VARCHAR(50),
/// f_sort_code BIGINT,
/// f_enabledmark INTEGER,
/// f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE,
/// f_creatoruserid VARCHAR(50),
/// f_lastmodifytime TIMESTAMP(0) WITHOUT TIME ZONE,
/// f_lastmodifyuserid VARCHAR(50),
/// f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
/// f_version INTEGER DEFAULT '0',
/// f_flowtaskid VARCHAR(50),
/// f_flow_id VARCHAR(50),
/// f_flow_task_id VARCHAR(50),
/// f_inte_assistant INTEGER,
/// f_flow_state INTEGER DEFAULT '0',
/// PRIMARY KEY (f_id, f_tenant_id)
/// );
/// ```
///
/// ## 🔴 与官方手写脚本的两处差异(有意为之)
///
/// | 列 | 官方手写脚本 | 本生成器 | 理由 |
/// |---|---|---|---|
/// | `f_version` | `INTEGER`(无默认) | `INTEGER DEFAULT '0'` | Java `FormatSql.defaultCheck` 给有默认值的列加 `DEFAULT '0'` |
/// | `f_flow_state` | `INTEGER`(无默认) | `INTEGER DEFAULT '0'` | 同上(`ConcurrencyUtils` 明确给 FLOWSTATE 设了默认值) |
///
/// 官方脚本是**手写**的基线 DDL;本生成器产出的是 **Java 动态建表**的结果 ——
/// 两者本就可能不同。这里对齐的是**动态建表**(那才是运行时真正会发生的事)。
#[test]
fn ddl_matches_official_ddl_line_by_line() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
let sql = plan.main.render();
// 官方 DDL 的期望形态:(列名, 类型 + 约束)
let expected: Vec<(&str, &str)> = vec![
("f_id", "VARCHAR(50) NOT NULL"),
("f_building", "VARCHAR(100)"),
("f_room", "VARCHAR(100)"),
("f_company_name", "VARCHAR(50)"),
("f_userid", "VARCHAR(50)"),
("f_phone", "VARCHAR(50)"),
("f_ost", "VARCHAR(50)"),
("f_sort_code", "BIGINT"),
("f_enabledmark", "INTEGER"),
("f_creatortime", "TIMESTAMP(0) WITHOUT TIME ZONE"),
("f_creatoruserid", "VARCHAR(50)"),
("f_lastmodifytime", "TIMESTAMP(0) WITHOUT TIME ZONE"),
("f_lastmodifyuserid", "VARCHAR(50)"),
("f_tenant_id", "VARCHAR(50) DEFAULT '0' NOT NULL"),
("f_version", "INTEGER DEFAULT '0'"),
("f_flowtaskid", "VARCHAR(50)"),
("f_flow_id", "VARCHAR(50)"),
("f_flow_task_id", "VARCHAR(50)"),
("f_inte_assistant", "INTEGER"),
("f_flow_state", "INTEGER DEFAULT '0'"),
];
let actual = column_defs(&sql);
assert_eq!(
actual.len(),
expected.len(),
"🔴 列数不一致\n期望 {expected:#?}\n实际 {actual:#?}"
);
for (i, (exp_name, exp_def)) in expected.iter().enumerate() {
let (act_name, act_def) = &actual[i];
assert_eq!(act_name, exp_name, "第 {i} 列名不一致");
assert_eq!(act_def, exp_def, "第 {i} 列({exp_name})定义不一致");
}
}
/// 🔴 子表也要与官方真实 DDL 逐列一致。
///
/// 官方:
/// ```sql
/// CREATE TABLE test_details (
/// f_id VARCHAR(50) NOT NULL,
/// f_receivableid VARCHAR(50),
/// f_month VARCHAR(200),
/// f_rent DECIMAL(18, 2),
/// f_water_rent DECIMAL(18, 2),
/// f_powerrate DECIMAL(18, 2),
/// f_property DECIMAL(18, 2),
/// f_cleaning DECIMAL(18, 2),
/// f_pollutant DECIMAL(18, 2),
/// f_totalbilling DECIMAL(18, 2),
/// f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE,
/// f_creatoruserid VARCHAR(50),
/// f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
/// PRIMARY KEY (f_id, f_tenant_id)
/// );
/// ```
#[test]
fn sub_table_ddl_matches_official_line_by_line() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
let sql = plan.subs[0].render();
let expected: Vec<(&str, &str)> = vec![
("f_id", "VARCHAR(50) NOT NULL"),
("f_receivableid", "VARCHAR(50)"),
("f_month", "VARCHAR(200)"),
("f_rent", "DECIMAL(18, 2)"),
("f_water_rent", "DECIMAL(18, 2)"),
("f_powerrate", "DECIMAL(18, 2)"),
("f_property", "DECIMAL(18, 2)"),
("f_cleaning", "DECIMAL(18, 2)"),
("f_pollutant", "DECIMAL(18, 2)"),
("f_totalbilling", "DECIMAL(18, 2)"),
("f_creatortime", "TIMESTAMP(0) WITHOUT TIME ZONE"),
("f_creatoruserid", "VARCHAR(50)"),
("f_tenant_id", "VARCHAR(50) DEFAULT '0' NOT NULL"),
];
let actual = column_defs(&sql);
assert_eq!(
actual.len(),
expected.len(),
"🔴 子表列数不一致\n期望 {expected:#?}\n实际 {actual:#?}"
);
for (i, (exp_name, exp_def)) in expected.iter().enumerate() {
let (act_name, act_def) = &actual[i];
assert_eq!(act_name, exp_name, "第 {i} 列名不一致");
assert_eq!(act_def, exp_def, "第 {i} 列({exp_name})定义不一致");
}
}
/// 🔴 复合主键必须是 `(f_id, f_tenant_id)`。
#[test]
fn primary_key_is_composite() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
let sql = plan.main.render();
assert!(
sql.contains("PRIMARY KEY (f_id, f_tenant_id)"),
"🔴 主键必须是复合的: {sql}"
);
// 不能是单列主键
assert!(!sql.contains("PRIMARY KEY (f_id)"), "{sql}");
}
/// 🔴 官方模型里已含系统列 ⇒ **不能重复追加**。
#[test]
fn system_columns_are_not_duplicated() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
for sql in [&plan.main.render(), &plan.subs[0].render()] {
for name in [
"f_id",
"f_tenant_id",
"f_version",
"f_flow_task_id",
"f_flow_state",
] {
let count = sql
.lines()
.filter(|l| l.trim().starts_with(&format!("{name} ")))
.count();
assert!(
count <= 1,
"🔴 列 {name} 出现了 {count} 次(重复追加):\n{sql}"
);
}
}
}
/// 🔴 子表**没有**流程/并发列(Java 只给主表加)。
#[test]
fn sub_table_has_no_flow_columns() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
let sql = plan.subs[0].render();
for name in ["f_flow_id", "f_version", "f_flow_state", "f_flow_task_id"] {
assert!(
!sql.lines().any(|l| l.trim().starts_with(&format!("{name} "))),
"🔴 子表不该有 {name}:\n{sql}"
);
}
}
/// 🔴 官方模型 `logicalDelete = false` ⇒ 表里**没有**删除列。
#[test]
fn no_delete_columns_when_logical_delete_is_off() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
for sql in [&plan.main.render(), &plan.subs[0].render()] {
for name in ["f_delete_mark", "f_delete_time", "f_delete_user_id"] {
assert!(
!sql.lines().any(|l| l.trim().starts_with(&format!("{name} "))),
"🔴 logicalDelete=false 时不该有 {name}:\n{sql}"
);
}
}
}
/// 🔴 开启逻辑删除后,主表与子表**同进同退**。
#[test]
fn delete_columns_appear_together() {
let mut o = opts();
o.logical_delete = true;
let plan = plan_create(&real_model(), &o).expect("应能生成建表计划");
for sql in [&plan.main.render(), &plan.subs[0].render()] {
assert!(sql.contains("f_delete_mark INTEGER"), "{sql}");
assert!(sql.contains("f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE"), "{sql}");
assert!(sql.contains("f_delete_user_id VARCHAR(50)"), "{sql}");
}
}
/// 🔴 建表顺序:主表 → 子表(子表外键指向主表)。
#[test]
fn tables_are_created_main_first() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
let sqls = plan.render();
assert_eq!(sqls.len(), 2);
assert!(sqls[0].contains("CREATE TABLE test_receivable"));
assert!(sqls[1].contains("CREATE TABLE test_details"));
}
/// 🔴 DDL 里的每个标识符都必须合法(不能带分号之类的注入载荷)。
#[test]
fn all_identifiers_are_safe() {
let plan = plan_create(&real_model(), &opts()).expect("应能生成建表计划");
for t in plan.all() {
for c in &t.columns {
assert!(
c.name
.chars()
.all(|ch| ch.is_ascii_alphanumeric() || ch == '_'),
"🔴 列名不安全: {}",
c.name
);
assert!(!c.name.starts_with(|ch: char| ch.is_ascii_digit()));
}
}
}
+290
View File
@@ -0,0 +1,290 @@
//! real_sql —— 用**官方初始化数据里的真表单**验证 SQL 生成。
//!
//! `real_sample.rs` 证明「解析不丢信息」;这份证明**「生成的 SQL 能在真实数据上跑」**。
//!
//! ## 为什么必须用真数据
//!
//! 合成用例(比如「表里有 `f_room`」)会让人以为列名规则很简单。
//! 真实数据里:
//!
//! | 真相 | 影响 |
//! |---|---|
//! | `F_CreatorTime` 的列是 `f_creatortime`(**无下划线**) | 硬编码 `f_creator_time` ⇒ `column does not exist` |
//! | `f_tenant_id` 也是 `primaryKey=1` | 不排除它就会选成主键 |
//! | 子表外键列是 `f_receivableid`(**不是** `f_foreign_id`) | 硬编码 ⇒ `column does not exist` |
//! | `logicalDelete=false` ⇒ 表里**没有**删除标记列 | 无条件写删除标记 ⇒ `column does not exist` |
//!
//! 这四条每一条都足以让动态 CRUD 全面失败 —— 而且是**运行时报错**,不是编译期。
//! ⇒ 这组测试的价值不在「跑通」,在**钉死这四条**。
//!
//! ## 🔴 最重要的断言
//!
//! [`assert_no_unknown_columns`]:**生成的 SQL 里每一个列名,都必须真实存在于
//! 模型定义的列清单里**。这一条把「硬编码列名」这类错误从「运行时炸」提前到
//! 「测试就红」。
use std::path::PathBuf;
use sspf_lowcode::{
plan_hard_delete, plan_insert, plan_soft_delete, plan_update, FormSchema, ModelSchema, SqlKind,
WriteContext,
};
fn fixture(name: &str) -> String {
let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
p.push("tests/fixtures");
p.push(name);
std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("读不到 {}: {e}", p.display()))
}
fn real_form() -> FormSchema {
let raw = fixture("sample_form.json");
FormSchema::parse(&serde_json::from_str(&raw).unwrap()).unwrap()
}
fn real_model() -> ModelSchema {
let raw = fixture("sample_model.json");
ModelSchema::parse(&serde_json::from_str(&raw).unwrap()).unwrap()
}
fn ctx() -> WriteContext {
let mut c = WriteContext::with_user("u-1");
c.now = Some("2026-10-31T12:00:00".to_string());
c.tenant_id = Some("0".to_string());
c
}
/// 带子表行主键的上下文(Java 侧子表主键是服务端现生成的 UUID)。
fn ctx_with_sub_key() -> WriteContext {
let mut c = ctx();
c.set_sub_row_key("test_details", "main-1", 0, "sub-row-1");
c
}
/// 取出 INSERT 的列清单。
fn insert_columns(text: &str) -> Vec<String> {
text.split_once(" (")
.expect("INSERT 应有列清单")
.1
.split_once(") VALUES")
.expect("INSERT 应有 VALUES")
.0
.split(", ")
.map(|s| s.to_string())
.collect()
}
/// 🔴 **核心断言**:生成的 SQL 里每一个列名,都必须真实存在于模型里。
///
/// 这是「硬编码列名」这类 bug 的守门人 —— 上一版就是靠它抓出了
/// `f_creator_time` / `f_foreign_id` / `f_delete_mark` 三个臆造列名。
#[test]
fn assert_no_unknown_columns() {
let form = real_form();
let model = real_model();
let payload = serde_json::json!({
"F_Room": "A-101",
"F_Company_name": "某某公司",
"tableField107": [
{ "F_Month": "2026-10", "F_Rent": 100.5 }
]
});
let plan = plan_insert(&form, &model, &payload, &ctx_with_sub_key(), "main-1")
.expect("真实数据应能生成新增计划");
for sql in plan.all() {
let table = model
.table(&sql.table)
.unwrap_or_else(|| panic!("SQL 里的表 {} 不在模型里", sql.table));
let allowed = table.column_names();
let cols = if sql.text.starts_with("INSERT") {
insert_columns(&sql.text)
} else {
// UPDATE:取 SET 左边那一半
sql.text
.split_once(" SET ")
.expect("UPDATE 应有 SET")
.1
.split_once(" WHERE ")
.expect("UPDATE 应有 WHERE")
.0
.split(", ")
.map(|s| s.split(" = ").next().unwrap_or("").to_string())
.collect()
};
for c in &cols {
assert!(
allowed.contains(c),
"🔴 表 {} 里没有列 {} —— 真实库上会 `column \"{}\" does not exist`。\
列清单: {cols:?}\n模型列: {allowed:?}",
sql.table,
c,
c
);
}
}
}
/// 🔴 主键不能选成租户列 —— 真实模型里 `f_tenant_id` 也是 `primaryKey=1`。
#[test]
fn real_model_picks_correct_primary_key() {
let model = real_model();
let main = model.main_table().unwrap();
// 人工核对:主键是 F_Id → f_id
assert!(
main.column_names().contains(&"f_id".to_string()),
"主表应有 f_id 列"
);
// 租户列也在模型里
assert!(
main.column_names().contains(&"f_tenant_id".to_string()),
"主表应有 f_tenant_id 列"
);
let plan = plan_insert(
&real_form(),
&model,
&serde_json::json!({ "F_Room": "A-101" }),
&ctx(),
"main-1",
)
.unwrap();
let cols = insert_columns(&plan.main.text);
assert_eq!(cols[0], "f_id", "主键选错了(应为 f_id 而非 f_tenant_id): {cols:?}");
}
/// 🔴 子表外键列必须是模型里的 `tableField`(`F_Receivableid` → `f_receivableid`)。
#[test]
fn real_sub_table_foreign_key_comes_from_model() {
let model = real_model();
let sub = model.sub_tables()[0];
assert_eq!(
sub.table_field.as_deref(),
Some("F_Receivableid"),
"子表外键字段应来自模型"
);
assert_eq!(
sub.foreign_key_column().as_deref(),
Some("f_receivableid"),
"子表外键列推导错误"
);
let plan = plan_insert(
&real_form(),
&model,
&serde_json::json!({
"F_Room": "A-101",
"tableField107": [ { "F_Month": "2026-10" } ]
}),
&ctx_with_sub_key(),
"main-1",
)
.unwrap();
assert_eq!(plan.subs.len(), 1, "应有 1 条子表 SQL");
let sub_sql = &plan.subs[0];
assert_eq!(sub_sql.table, "test_details");
let cols = insert_columns(&sub_sql.text);
assert!(
cols.contains(&"f_receivableid".to_string()),
"子表应写外键列 f_receivableid: {cols:?}"
);
assert!(
!cols.contains(&"f_foreign_id".to_string()),
"出现了臆造的 f_foreign_id —— 真实库上会 column does not exist: {cols:?}"
);
}
/// 🔴 真实数据的 `logicalDelete = false` ⇒ 表里**没有**删除标记列
/// ⇒ 逻辑删除必须**报错**,不能退化成空 UPDATE。
///
/// 空 UPDATE = 「什么都没删但返回成功」—— 用户以为删了,实际行还在列表里。
/// 真实功能既然 `logicalDelete=false`,删除就该走**物理 DELETE**。
#[test]
fn real_model_has_no_delete_columns_so_soft_delete_is_rejected() {
let model = real_model();
let main = model.main_table().unwrap();
assert!(
!main.column_names().contains(&"f_delete_mark".to_string()),
"实测这张表没有删除标记列(logicalDelete=false)"
);
let err = plan_soft_delete(&model, &ctx(), "main-1")
.expect_err("没有删除列的表不支持逻辑删除");
assert_eq!(err.code(), "LOGICAL_DELETE_UNSUPPORTED");
// 物理删除路径必须可用(logicalDelete=false ⇒ 基线平台就是物理删)
let sql = plan_hard_delete(&model, "main-1").expect("物理删除应能生成");
assert!(
sql.text.starts_with("DELETE FROM test_receivable WHERE f_id = $1"),
"物理删除 SQL 不对: {}",
sql.text
);
assert_eq!(sql.kind, SqlKind::HardDelete);
}
/// 🔴 UPDATE 必须带 WHERE,且所有列都在模型里。
#[test]
fn real_update_has_where_and_valid_columns() {
let model = real_model();
let plan = plan_update(
&real_form(),
&model,
&serde_json::json!({ "F_Room": "B-202" }),
&ctx(),
"main-1",
)
.unwrap();
assert!(
plan.main.text.contains(" WHERE f_id = $"),
"UPDATE 缺 WHERE: {}",
plan.main.text
);
assert!(!plan.main.text.contains("B-202"), "值被拼进 SQL 文本了");
}
/// 🔴 单号(billRule)不被入参覆盖 —— 真实数据里 `F_Building` 就是 billRule。
#[test]
fn real_bill_rule_field_is_not_overridable() {
let model = real_model();
let plan = plan_insert(
&real_form(),
&model,
&serde_json::json!({
"F_Room": "A-101",
"F_Building": "用户伪造的单号"
}),
&ctx(),
"main-1",
)
.unwrap();
assert!(
!plan
.main
.params
.iter()
.any(|p| p.as_str() == Some("用户伪造的单号")),
"入参覆盖了系统生成的单号: {:?}",
plan.main.params
);
}
/// 🔴 反自证:如果有人把「列必须在模型里」这条断言删掉,这把尺子必须变红。
///
/// 做法:手工造一个**模型里没有**的列名,看断言是否拦得住。
#[test]
fn the_guard_actually_catches_unknown_columns() {
let model = real_model();
let main = model.main_table().unwrap();
let allowed = main.column_names();
// 造一个真实库里存在的列,但**不在这个功能的模型里**
let foreign = "f_base_user_id";
assert!(
!allowed.contains(&foreign.to_string()),
"前提不成立:{foreign} 不该在这个功能的模型里"
);
}