diff --git a/.workbuddy/memory/2026-10-31.md b/.workbuddy/memory/2026-10-31.md index 9e9dbbb..6cfb65a 100644 --- a/.workbuddy/memory/2026-10-31.md +++ b/.workbuddy/memory/2026-10-31.md @@ -689,3 +689,17 @@ Java `FlowFormDataUtil.create()` 里 `CALCULATE` 走 `getIntValue(dataValue, ... ### 数字 `cargo test` **346**(+2:AutoFill 两条)|十二道闸门全绿 | `lowcode-smoke` 8/8 + +--- + +## pglite 0.2.7 退出码 100 根因与修复(18:53 续) + +**现象**:`ssw-platform`(任意开库子命令:--seed-lowcode-demo / --mcp / 默认 HTTP)在 **stdout 被重定向到 `/dev/null`** 时退出码 **100** 且残留 `postmaster.pid`;`stderr` 无任何 Rust panic 输出。 + +**根因**(lldb 调用栈确认):内嵌 PG 在 boot 阶段 `pq_init → WaitEventAdjustKqueue`(macOS kqueue)对 **fd 1** 注册读事件;当 fd 1 是字符设备(`/dev/null`)时 `kevent()` 失败,`ereport(ERROR)` 走 `pg_re_throw → pgl_siglongjmp`,但 `pgl_startPGlite` 不在 `sigsetjmp` 上下文 ⇒ 回落 `pgl_native_exit(100)`。 +- 只有 fd 1 是字符设备才触发;stderr=`/dev/null`、fd1=普通文件/管道/tty 都正常。 +- 之前 MCP 没暴露:因 `detach_stdio_for_mcp()` 把 fd1→fd2(当时 fd2 是普通文件/管道)。 + +**修复**:在唯一开库入口 `open_db()`(src/backend/src/main.rs)开库前加 `#[cfg(unix)] ensure_stdout_for_pglite()` —— 若 fd 1 是字符设备或已关闭,把它 `dup2` 到一个匿名普通临时文件(`/tmp/ssw-pglite-stdout-.log`,进程级泄漏保活)。MCP 协议走 `dup` 出来的独立 fd,不受 fd1 改动影响。 + +**验证**:seed 四种重定向组合(file/file、/dev/null/file、file//dev/null、both//dev/null)全 EXIT=0 且无 pid 残留;MCP `1>/null 2>/null` EXIT=0 无残留;默认 HTTP `> /dev/null` EXIT=124(timeout) 无残留。`cargo test -p ssw-platform` 全量 0 failed。 diff --git a/crates/sspf-lowcode/src/ddl.rs b/crates/sspf-lowcode/src/ddl.rs new file mode 100644 index 0000000..5e0c9c7 --- /dev/null +++ b/crates/sspf-lowcode/src/ddl.rs @@ -0,0 +1,1651 @@ +//! ddl —— 动态建表的 **DDL 生成**(纯计算,不连库)。 +//! +//! ## 它对齐的是哪套建表规则 +//! +//! 基线平台的动态建表链路: +//! +//! ```text +//! VisualdevServiceImpl.createTable() +//! → FormCloumnUtil.recursionForm() ← 解析表单控件树 +//! → VisualDevTableCre.tableList() ← 拼装字段清单 +//! → fieldList() / dbTableField() / dbTable() +//! → ServiceBaseUtil.createTable() +//! → DbTableServiceImpl.createTable() +//! → SqlFastUtil.creTable() ← 真正拼 CREATE TABLE +//! ``` +//! +//! 本模块对齐的是 `VisualDevTableCre.tableList()` 的**规则**, +//! 但**输入不同**(见下),输出是 PostgreSQL 的 `CREATE TABLE` 文本。 +//! +//! ## 🔴 输入为什么是 `ModelSchema` 而不是 `FormSchema` +//! +//! Java 的 `fieldList()` 是**从表单控件**逐个拼列的: +//! +//! ```java +//! for (FieLdsModel tableFieLdsModel : fieldsList) { +//! this.fieldList(tableFieLdsModel, tableName, tableList, mappingList); +//! } +//! ``` +//! +//! 也就是说,**表单里有的控件才建列**。但 `f_tables_data`(模型)里 +//! 记录的是**建表之后回写的完整表结构** —— 它是基线平台自己的真源, +//! 且官方初始化数据里的 `test_receivable` / `test_details` 就是它的产物。 +//! +//! ⇒ 本模块以 [`ModelSchema`] 为主输入: +//! +//! | | Java(表单驱动) | 本模块(模型驱动) | +//! |---|---|---| +//! | 列来源 | 表单控件 | `f_tables_data` 的 `fields` | +//! | 列类型 | 由 `jnpfKey` 猜(`inputNumber` ⇒ decimal) | 模型里已有 `dataType` | +//! | 长度 | 控件默认(`255` / `38,15`) | 模型里已有 `dataLength` | +//! +//! 用模型驱动的好处:**类型和长度是设计稿里已经定好的事实**, +//! 不用再从控件类型反推 —— 反推必然有偏差(`billRule` 到底是 varchar +//! 还是 text?`rate` 的精度是几位?)。 +//! +//! ## 🔴 三处与 Java 源码的**已知差异**(必须记录,不能装作一致) +//! +//! 1. **子表外键列名** +//! Java `dbTableField()` 硬编码 `TableFeildsEnum.FOREIGN` ⇒ `f_foreign_id`; +//! 但官方真实 DDL(`jnpf_db_init.sql`)与官方 fixture 里,子表外键列是 +//! `f_receivableid`(= 模型的 `tableField`)。 +//! ⇒ 本模块采用**模型驱动**的外键列(`tableField`), +//! 与官方真实表结构一致,也与已实现的 CRUD 层一致。 +//! 2. **列来源**:见上(模型 vs 表单)。 +//! 3. **COMMENT**:Java 单独发 `COMMENT ON` 语句;本模块可选把注释内联到 +//! `COMMENT ON COLUMN` 语句里(默认关)。 +//! +//! ## 🔴 主键是**复合**的 +//! +//! 官方真实 DDL: +//! ```sql +//! PRIMARY KEY (f_id, f_tenant_id) +//! ``` +//! +//! 原因在 `TableFeildsEnum`:`FID` 和 `TENANTID` 的 `primaryKey` **都是 true**。 +//! ⇒ 本模块的复合主键由**模型里所有 `primaryKey = true` 的列**组成, +//! 而不是硬编码 `(f_id, f_tenant_id)` —— 硬编码等于假设「租户列一定存在」。 +//! +//! ## 🔴 系统列的**特征**而不是名字 +//! +//! 与 [`crate::sql`] 同一原则:系统列靠**字段名特征**定位, +//! 因为官方数据里 `F_CreatorTime` 推出的列是 `f_creatortime`(无下划线), +//! 而 `f_creator_time` 是平台表 `base_*` 的手写 DDL 风格。 +//! +//! 但**建表**这里不一样:建表时系统列是平台**追加**的,名字是确定的常量 +//! (`f_tenant_id` / `f_flow_id` / `f_version` / `f_flow_task_id` / `f_flow_state` +//! / `f_delete_mark` / `f_delete_time` / `f_delete_user_id`), +//! 且 PG 下转小写 —— 这些是 [`crate::sql::sys`] 里的常量,直接用。 +//! +//! ## 纯计算(AR7) +//! +//! 本模块不引 `pglite` / `axum` / `tokio` —— 只产出 SQL 文本。 +//! 内核侧负责执行(`src/backend/src/lowcode_ddl.rs`)。 + +use std::collections::BTreeMap; + +use crate::model::{ModelSchema, TableSchema}; +use crate::sql::{check_identifier, sys}; + +/// 建表 DDL 生成时的错误。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum DdlError { + /// 没有主表(模型里没有 `typeId = "1"` 的表)。 + NoMainTable, + /// 标识符非法(表名/列名不是合法 SQL 标识符)。 + IllegalIdentifier { kind: &'static str, value: String }, + /// 模型里的列定义有冲突(两列推出同一个物理列名)。 + DuplicateColumn { table: String, column: String }, + /// 类型不认识。 + /// + /// 🔴 **不静默降级成 varchar** —— 降级会让数值列变文本, + /// 排序/求和全错,而且**不报错**。宁可建表失败让人来看。 + UnsupportedType { table: String, column: String, data_type: String }, + /// 长度/精度不合法。 + InvalidLength { table: String, column: String, length: String }, + /// 主键为空(模型里没有 `primaryKey = true` 的列)。 + NoPrimaryKey(String), +} + +impl DdlError { + /// 机器可读码。 + pub fn code(&self) -> &'static str { + match self { + DdlError::NoMainTable => "NO_MAIN_TABLE", + DdlError::IllegalIdentifier { .. } => "ILLEGAL_IDENTIFIER", + DdlError::DuplicateColumn { .. } => "DUPLICATE_COLUMN", + DdlError::UnsupportedType { .. } => "UNSUPPORTED_TYPE", + DdlError::InvalidLength { .. } => "INVALID_LENGTH", + DdlError::NoPrimaryKey(_) => "NO_PRIMARY_KEY", + } + } + + /// 人话描述。 + pub fn message(&self) -> String { + match self { + DdlError::NoMainTable => "模型里没有主表(typeId=1)".to_string(), + DdlError::IllegalIdentifier { kind, value } => { + format!("{kind}「{value}」不是合法标识符") + } + DdlError::DuplicateColumn { table, column } => { + format!("表 {table} 里有两列推出同一个物理列名 {column}") + } + DdlError::UnsupportedType { + table, + column, + data_type, + } => format!( + "表 {table} 的列 {column} 的类型「{data_type}」不认识 —— \ + 不会静默降级成 varchar(那会让数值列变文本,排序/求和全错)" + ), + DdlError::InvalidLength { + table, + column, + length, + } => format!("表 {table} 的列 {column} 的长度「{length}」不合法"), + DdlError::NoPrimaryKey(t) => format!("表 {t} 没有主键(模型里没有 primaryKey=true 的列)"), + } + } +} + +/// 一个列的 DDL 定义。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ColumnDdl { + /// 物理列名(小写)。 + pub name: String, + /// 完整的类型片段(如 `VARCHAR(50)`、`TIMESTAMP(0) WITHOUT TIME ZONE`)。 + pub sql_type: String, + /// 是否 `NOT NULL`。 + pub not_null: bool, + /// 默认值字面量(已带引号,如 `'0'`);`None` ⇒ 无默认值。 + pub default: Option, + /// 是否参与复合主键。 + pub primary_key: bool, + /// 列注释(可选)。 + pub comment: Option, + /// 🔴 回写模型时用的**设计态字段名**(`F_Room` / `f_tenant_id`)。 + /// + /// ## 为什么建模 DDL 还要带这个 + /// + /// JNPF 建表后会**回写** `f_tables_data`(`VisualDevTableCre.tableModel()` + /// 用建表清单重新组装 `TableModel`),回写后的字段名是**设计态**的。 + /// 业务列沿用模型里原有的 `field`(`F_Room`), + /// 平台追加的系统列用小写常量(`f_tenant_id`)。 + pub model_field: String, + /// 回写模型时用的 `dataType`(**JNPF 视图类型**:`varchar`/`text`/`int`/ + /// `bigint`/`decimal`/`datetime`)。 + pub model_data_type: String, + /// 回写模型时用的 `dataLength`。 + /// + /// 🔴 官方数据的口径:**只有 `varchar` / `decimal` 有长度**, + /// `int` / `bigint` / `datetime` 一律 `null`。 + pub model_data_length: Option, +} + +impl ColumnDdl { + /// 渲染成 `CREATE TABLE` 里的一行。 + /// + /// ## 🔴 顺序:`DEFAULT` 在 `NOT NULL` 之前 + /// + /// 官方真实 DDL: + /// ```sql + /// f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + /// ``` + /// + /// 顺序反了虽然 PG 也接受,但与官方 DDL 不同形 ⇒ 断言会对不上。 + fn render(&self) -> String { + let mut s = format!(" {} {}", self.name, self.sql_type); + if let Some(d) = &self.default { + s.push_str(" DEFAULT "); + s.push_str(d); + } + if self.not_null { + s.push_str(" NOT NULL"); + } + s + } +} + +/// 一张表的 DDL 定义。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TableDdl { + /// 物理表名(小写)。 + pub table: String, + /// 表注释。 + pub comment: Option, + /// 列定义(**按建表顺序**,即最终 SQL 里的顺序)。 + pub columns: Vec, +} + +impl TableDdl { + /// 渲染成 `CREATE TABLE` 语句。 + /// + /// ## 🔴 列顺序 = 官方真实 DDL 的顺序 + /// + /// 官方 `test_receivable`: + /// ```text + /// f_id → f_building → … → f_lastmodifyuserid → f_tenant_id → f_version + /// → f_flowtaskid → f_flow_id → f_flow_task_id → f_inte_assistant → f_flow_state + /// ``` + /// + /// ⇒ 主键列在前,系统列在后,追加的删除列最后。 + pub fn render(&self) -> String { + let mut s = format!("CREATE TABLE {} (\n", self.table); + let body: Vec = self.columns.iter().map(|c| c.render()).collect(); + s.push_str(&body.join(",\n")); + let pks: Vec<&str> = self + .columns + .iter() + .filter(|c| c.primary_key) + .map(|c| c.name.as_str()) + .collect(); + if !pks.is_empty() { + s.push_str(",\n PRIMARY KEY ("); + s.push_str(&pks.join(", ")); + s.push(')'); + } + s.push_str("\n);"); + s + } + + /// 全部列名(按顺序)。 + pub fn column_names(&self) -> Vec { + self.columns.iter().map(|c| c.name.clone()).collect() + } + + /// 渲染成 `COMMENT ON COLUMN` 语句(可选)。 + pub fn render_comments(&self) -> Vec { + let mut out = Vec::new(); + if let Some(tc) = &self.comment { + out.push(format!( + "COMMENT ON TABLE {} IS '{}';", + self.table, + escape_literal(tc) + )); + } + for c in &self.columns { + if let Some(cm) = &c.comment { + out.push(format!( + "COMMENT ON COLUMN {}.{} IS '{}';", + self.table, + c.name, + escape_literal(cm) + )); + } + } + out + } +} + +/// 一次建表的完整产物(主表 + 所有子表)。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CreatePlan { + /// 主表 DDL。 + pub main: TableDdl, + /// 子表 DDL(按模型里的顺序)。 + pub subs: Vec, +} + +impl CreatePlan { + /// 全部 DDL(主表在前)。 + pub fn all(&self) -> Vec<&TableDdl> { + let mut v: Vec<&TableDdl> = vec![&self.main]; + v.extend(self.subs.iter()); + v + } + + /// 渲染全部 `CREATE TABLE` 语句(主表在前)。 + /// + /// ## 🔴 顺序:主表 → 子表 + /// + /// 子表外键指向主表 ⇒ 主表必须先存在。 + pub fn render(&self) -> Vec { + self.all().iter().map(|t| t.render()).collect() + } + + /// 一共建几张表。 + pub fn table_count(&self) -> usize { + 1 + self.subs.len() + } +} + +/// 建表选项。 +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct DdlOptions { + /// 是否逻辑删除。 + /// + /// 🔴 决定**追加哪三个删除列**: + /// `f_delete_mark` / `f_delete_time` / `f_delete_user_id`。 + /// + /// 基线平台 `VisualDevTableCre.tableList()`: + /// ```java + /// if (Boolean.TRUE.equals(visualTableModel.getLogicalDelete())) { + /// fieldList.add(...DELETEMARK...); + /// fieldList.add(...DELETETIME...); + /// fieldList.add(...DELETEUSERID...); + /// } + /// ``` + /// + /// 主表与子表**同进同退**(这正是 CRUD 层 `LOGICAL_DELETE_UNSUPPORTED` + /// 错误存在的原因)。 + pub logical_delete: bool, + /// 是否写 `COMMENT ON` 语句。 + pub with_comments: bool, + /// 主键策略(`primaryKeyPolicy`)。 + /// + /// | 值 | 含义 | 主键列类型 | + /// |---|---|---| + /// | `1` | 雪花 ID(默认) | `VARCHAR(50)` | + /// | `2` | 自增 | PostgreSQL `SERIAL` | + /// + /// 🔴 官方 fixture 是 `1` ⇒ `VARCHAR(50)`。 + /// `2` ⇒ PG 下用 `SERIAL`(Java `SqlPostgreSQLEnum.createIncrement`)。 + pub primary_key_policy: i64, +} + +impl DdlOptions { + /// 默认选项(雪花 ID 主键、无逻辑删除、不写注释)。 + pub fn default_options() -> Self { + Self { + logical_delete: false, + with_comments: false, + primary_key_policy: 1, + } + } +} + +/// 🔴 **单租户**下的默认租户值。 +/// +/// 基线平台 `GlobalConst.DEFAULT_TENANT_VALUE = "0"`, +/// `TenantDataSourceUtil.getTenantColumn()` 在单租户下恒返回它。 +pub const DEFAULT_TENANT_ID: &str = "0"; + +/// 🔴 建表后**回写模型**(`f_tables_data`)—— 把建出来的真实表结构写回设计稿。 +/// +/// ## 为什么这是**必须**的一步(不是可选的优化) +/// +/// 基线平台 `VisualDevTableCre.tableList()` 建完表后: +/// +/// ```java +/// this.tableModel(tableModelList, datableList, tableName, table, true, tableField, relationField); +/// ... +/// entity.setVisualTables(JsonUtil.getObjectToString(tableModelList)); +/// ``` +/// +/// `tableModel()` 用**建表清单**(含平台追加的系统列)重新组装 `TableModel`, +/// 再写回 `f_tables_data`。⇒ **建表后的模型里有系统列**, +/// 而建表前的模型里没有。 +/// +/// ## 🔴 不回写的后果(本项目已真实踩到) +/// +/// 1. 逻辑删除报 `LOGICAL_DELETE_UNSUPPORTED` —— +/// CRUD 层在**模型**里找 `f_delete_mark`,找不到就报错, +/// 尽管真实库里明明有这一列; +/// 2. 「设计稿 vs 真实库」列比对永远对不上(模型少列、真实库多列); +/// 3. `f_tenant_id` 这类系统列在模型里缺失 ⇒ 租户列不会被写。 +/// +/// ## 🔴 回写后的字段形态(对齐官方真实数据) +/// +/// 官方 `f_tables_data` 的字段对象: +/// +/// ```json +/// { +/// "allowNull": 1, "autoIncrement": 0, "columnName": null, +/// "dataLength": "50", "dataType": "varchar", "dataTypeName": null, +/// "dataTypeReal": null, "field": "F_Room", "fieldName": "房间号", +/// "identity": 0, "primaryKey": 0 +/// } +/// ``` +/// +/// - `field`:业务列沿用模型原有的(`F_Room`),系统列用小写常量(`f_tenant_id`); +/// - `dataType`:**视图类型**(`varchar`/`text`/`int`/`bigint`/`decimal`/`datetime`); +/// - `dataLength`:**只有 `varchar` / `decimal` 有长度**,其余 `null`; +/// - `columnName`:仍为 `null`(官方数据里它一直是 `null`)。 +/// +/// ## 🔴 表级字段也一起对齐 +/// +/// `tableName` = 表显示名,`comment` = `"主表"` / `"子表"`(Java `tableModel()`), +/// `tableField` / `relationField` / `relationTable` 按主/子表区分。 +pub fn rewrite_model( + model: &ModelSchema, + plan: &CreatePlan, +) -> serde_json::Value { + let mut out: Vec = Vec::new(); + + // 主表 + if let Some(main) = model.main_table() { + out.push(table_model_json(main, &plan.main, "主表", model)); + } + // 子表 + for (sub_model, sub_ddl) in model.sub_tables().iter().zip(plan.subs.iter()) { + out.push(table_model_json(sub_model, sub_ddl, "子表", model)); + } + + serde_json::Value::Array(out) +} + +/// 组装一张表的模型 JSON(回写形态)。 +fn table_model_json( + model_table: &TableSchema, + ddl: &TableDdl, + comment: &str, + model: &ModelSchema, +) -> serde_json::Value { + // 🔴 回写后的 `field` 要能对上模型里的原字段名 —— + // 业务列沿用原 `field`,系统列用小写常量。 + // 先建一张「物理列名 → 设计态字段名」的映射(取模型里的原名)。 + let mut field_names: std::collections::BTreeMap = + std::collections::BTreeMap::new(); + for def in &model_table.fields { + if let Some(col) = def.resolved_column() { + field_names + .entry(col) + .or_insert_with(|| def.field.clone()); + } + } + + let fields: Vec = ddl + .columns + .iter() + .map(|c| { + let field = field_names + .get(&c.name) + .cloned() + .unwrap_or_else(|| c.model_field.clone()); + serde_json::json!({ + "allowNull": if c.not_null { 0 } else { 1 }, + "autoIncrement": 0, + "columnName": serde_json::Value::Null, + "dataLength": match &c.model_data_length { + Some(l) => serde_json::Value::String(l.clone()), + None => serde_json::Value::Null, + }, + "dataType": c.model_data_type, + "dataTypeName": serde_json::Value::Null, + "dataTypeReal": serde_json::Value::Null, + "field": field, + "fieldName": c.comment.clone().unwrap_or_default(), + "identity": 0, + "primaryKey": if c.primary_key { 1 } else { 0 }, + }) + }) + .collect(); + + // 子表的 `tableField` / `relationField` / `relationTable`: + // Java `tableModel()` 对子表写 `tableField`(外键)、`relationTable`(主表名)、 + // `relationField`(主表关联列);主表三项都写空串。 + let (table_field, relation_field, relation_table) = if model_table.is_main() { + (String::new(), String::new(), String::new()) + } else { + ( + model_table.table_field.clone().unwrap_or_default(), + model_table.relation_field.clone().unwrap_or_default(), + model_table + .relation_table + .clone() + .or_else(|| model.main_table().map(|m| m.table.clone())) + .unwrap_or_default(), + ) + }; + + serde_json::json!({ + "relationTable": relation_table, + "tableField": table_field, + "typeId": model_table.type_id, + "fields": fields, + "relationField": relation_field, + "table": ddl.table, + "tableName": model_table.table_name, + "comment": comment, + }) +} + +/// 生成一次完整的建表计划。 +/// +/// ## 🔴 系统列的追加规则(来自 Java 源码) +/// +/// **主表**(`VisualDevTableCre.tableList()` 第 268–278 行): +/// ```text +/// dbTableField(fieldList, false, ...) → 追加 f_id(主键) +/// + TENANTID → f_tenant_id(主键) +/// + FLOWID → f_flow_id +/// + VERSION → f_version +/// + FLOWTASKID → f_flow_task_id +/// + FLOWSTATE → f_flow_state +/// + [logicalDelete] DELETEMARK/DELETETIME/DELETEUSERID +/// ``` +/// +/// **子表**(第 262、285–293 行): +/// ```text +/// dbTableField(tableList, true, ...) → 追加 f_id(主键)+ 外键列 +/// + TENANTID → f_tenant_id(主键) +/// + [logicalDelete] DELETEMARK/DELETETIME/DELETEUSERID +/// ``` +/// +/// ⇒ 子表**没有** `f_flow_id` / `f_version` / `f_flow_task_id` / `f_flow_state`。 +pub fn plan_create( + model: &ModelSchema, + options: &DdlOptions, +) -> Result { + let main = model.main_table().ok_or(DdlError::NoMainTable)?; + + let main_ddl = build_table(model, main, options, Role::Main)?; + let mut subs = Vec::new(); + for sub in model.sub_tables() { + subs.push(build_table(model, sub, options, Role::Sub)?); + } + + Ok(CreatePlan { main: main_ddl, subs }) +} + +/// 表在体系里的角色。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Role { + /// 主表。 + Main, + /// 子表。 + Sub, +} + +/// 构造一张表的 DDL。 +fn build_table( + model: &ModelSchema, + table: &TableSchema, + options: &DdlOptions, + role: Role, +) -> Result { + let tname = table.table.to_lowercase(); + check_identifier("表名", &tname).map_err(|_| DdlError::IllegalIdentifier { + kind: "表名", + value: tname.clone(), + })?; + + let mut columns: Vec = Vec::new(); + let mut seen: BTreeMap = BTreeMap::new(); + + // 🔴 子表外键列(模型驱动,不是 Java 的 `f_foreign_id`)。 + // 官方真实 DDL 与 fixture 里子表外键是 `f_receivableid`(= 模型 `tableField`)。 + let fk_col = if role == Role::Sub { + let fk = table.foreign_key_column().ok_or_else(|| DdlError::UnsupportedType { + table: tname.clone(), + column: "tableField".to_string(), + data_type: "子表缺少 tableField(外键列无从推导)".to_string(), + })?; + check_identifier("列名", &fk).map_err(|_| DdlError::IllegalIdentifier { + kind: "列名", + value: fk.clone(), + })?; + Some(fk) + } else { + None + }; + + // ---- 遍历模型字段(**按模型顺序**)---- + // + // ## 🔴 为什么直接用模型顺序 + // + // 官方模型 `f_tables_data` 是**建表之后回写**的 —— 它记录了建出来的真实列序。 + // 官方真实 DDL 的列序与模型顺序**逐列一致**: + // + // ```text + // 模型:F_Id, F_Building, …, F_LastModifyUserId, f_tenant_id, f_version, + // f_flowtaskid, f_flow_id, f_flow_task_id, f_inte_assistant, f_flow_state + // DDL :f_id, f_building, …, f_lastmodifyuserid, f_tenant_id, f_version, + // f_flowtaskid, f_flow_id, f_flow_task_id, f_inte_assistant, f_flow_state + // ``` + // + // ⇒ **模型顺序即官方顺序**。Java 那边是「业务列在前、系统列追加在后」, + // 但那是因为 Java 从表单控件出发;模型已经是结果,不需要再重排。 + for def in &table.fields { + let Some(name) = def.resolved_column() else { + continue; + }; + if seen.contains_key(&name) { + return Err(DdlError::DuplicateColumn { + table: tname.clone(), + column: name, + }); + } + check_identifier("列名", &name).map_err(|_| DdlError::IllegalIdentifier { + kind: "列名", + value: name.clone(), + })?; + + // ---- 主键列 `f_id` ---- + // Java `dbTableField()` 单独加:VARCHAR(50) NOT NULL(或自增策略的 SERIAL)。 + if name == sys::F_ID { + seen.insert(name.clone(), ()); + let auto = options.primary_key_policy == 2; + columns.push(ColumnDdl { + name, + sql_type: if auto { + "SERIAL".to_string() + } else { + "VARCHAR(50)".to_string() + }, + not_null: true, + default: None, + primary_key: true, + comment: Some("主键".to_string()), + model_field: "F_Id".to_string(), + model_data_type: if auto { + "int".to_string() + } else { + "varchar".to_string() + }, + model_data_length: if auto { None } else { Some("50".to_string()) }, + }); + continue; + } + + // ---- 子表外键列 ---- + if fk_col.as_deref() == Some(name.as_str()) { + seen.insert(name.clone(), ()); + columns.push(ColumnDdl { + name, + sql_type: "VARCHAR(50)".to_string(), + not_null: false, + default: None, + primary_key: false, + comment: Some("外键".to_string()), + model_field: def.field.clone(), + model_data_type: "varchar".to_string(), + model_data_length: Some("50".to_string()), + }); + continue; + } + + // ---- 平台系统列:类型/默认值**以平台常量为准** ---- + // + // 模型里这些列的 `dataType`/`dataLength` 可能不准 + // (如 `f_version` 的 `dataType` 是 `int` 但 `dataLength` 是 null), + // 而建表规范由平台常量钉死 ⇒ 用平台规范覆盖。 + if let Some(spec) = SystemColumn::by_name(&name) { + // 🔴 子表**没有**流程/并发列(Java 只给主表加)⇒ 跳过。 + if role == Role::Sub && spec.is_main_only() { + continue; + } + seen.insert(name.clone(), ()); + columns.push(spec.to_column()); + continue; + } + + // ---- 普通业务列 ---- + let spec = map_type(&tname, &name, &def.data_type, &def.data_length)?; + seen.insert(name.clone(), ()); + columns.push(ColumnDdl { + name, + sql_type: spec.sql_type, + not_null: !def.allow_null, + default: None, + primary_key: false, + comment: Some(def.field_name.clone()).filter(|s| !s.is_empty()), + model_field: def.field.clone(), + model_data_type: spec.view_type, + model_data_length: spec.length, + }); + } + + // ---- 追加「模型里没有、但 Java 建表会加」的系统列 ---- + // + // Java `tableList()` 无条件追加: + // 主表 = TENANTID / FLOWID / VERSION / FLOWTASKID / FLOWSTATE + // 子表 = TENANTID + // + // 官方 fixture 的模型里**已经含**这些列 ⇒ 这里什么都不会加(幂等)。 + // 若某个设计稿的模型是「设计完还没建表」的形态(模型里没有系统列), + // 这里补齐 —— 与 Java 建表结果一致。 + let wanted: Vec = match role { + Role::Main => vec![ + SystemColumn::TenantId, + SystemColumn::FlowId, + SystemColumn::Version, + SystemColumn::FlowTaskId, + SystemColumn::FlowState, + ], + Role::Sub => vec![SystemColumn::TenantId], + }; + for sys_col in wanted { + add_system_column(&mut columns, &mut seen, sys_col); + } + + // ---- 逻辑删除列(主表与子表同进同退)---- + if options.logical_delete { + for sys_col in [ + SystemColumn::DeleteMark, + SystemColumn::DeleteTime, + SystemColumn::DeleteUserId, + ] { + add_system_column(&mut columns, &mut seen, sys_col); + } + } + + // ---- 复合主键 ---- + // Java:所有 `isPrimaryKey = true` 的列进 PRIMARY KEY。 + // `TableFeildsEnum` 里 FID 与 TENANTID 的 primaryKey 都是 true + // ⇒ 官方真实 DDL 是 `PRIMARY KEY (f_id, f_tenant_id)`。 + if !columns.iter().any(|c| c.primary_key) { + return Err(DdlError::NoPrimaryKey(tname)); + } + + let _ = model; + + Ok(TableDdl { + table: tname, + comment: Some(table.table_name.clone()).filter(|s| !s.is_empty()), + columns, + }) +} + +/// 平台追加的系统列。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum SystemColumn { + TenantId, + FlowId, + Version, + FlowTaskId, + FlowState, + DeleteMark, + DeleteTime, + DeleteUserId, +} + +impl SystemColumn { + /// 列名(已是 PG 小写形态)。 + fn name(self) -> &'static str { + match self { + SystemColumn::TenantId => sys::TENANTID, + SystemColumn::FlowId => "f_flow_id", + SystemColumn::Version => sys::VERSION, + SystemColumn::FlowTaskId => sys::FLOWTASKID, + SystemColumn::FlowState => "f_flow_state", + SystemColumn::DeleteMark => sys::DELETE_MARK, + SystemColumn::DeleteTime => sys::DELETE_TIME, + SystemColumn::DeleteUserId => sys::DELETE_USER_ID, + } + } + + /// 按列名找系统列(模型里遇到时用平台规范覆盖)。 + fn by_name(name: &str) -> Option { + let n = name.to_lowercase(); + match n.as_str() { + sys::TENANTID => Some(SystemColumn::TenantId), + "f_flow_id" => Some(SystemColumn::FlowId), + sys::VERSION => Some(SystemColumn::Version), + sys::FLOWTASKID => Some(SystemColumn::FlowTaskId), + "f_flow_state" => Some(SystemColumn::FlowState), + sys::DELETE_MARK => Some(SystemColumn::DeleteMark), + sys::DELETE_TIME => Some(SystemColumn::DeleteTime), + sys::DELETE_USER_ID => Some(SystemColumn::DeleteUserId), + _ => None, + } + } + + /// 是否**只属于主表**(Java 只给主表加流程/并发列)。 + fn is_main_only(self) -> bool { + matches!( + self, + SystemColumn::FlowId + | SystemColumn::Version + | SystemColumn::FlowTaskId + | SystemColumn::FlowState + ) + } + + /// 类型片段。 + fn sql_type(self) -> &'static str { + match self { + SystemColumn::TenantId => "VARCHAR(50)", + SystemColumn::FlowId => "VARCHAR(50)", + SystemColumn::Version => "INTEGER", + SystemColumn::FlowTaskId => "VARCHAR(50)", + SystemColumn::FlowState => "INTEGER", + // 🔴 官方真实 DDL:`f_delete_mark INTEGER`(**不是 boolean**)。 + // Java `TableFeildsEnum.DELETEMARK` 也是 `"int"`。 + SystemColumn::DeleteMark => "INTEGER", + SystemColumn::DeleteTime => "TIMESTAMP(0) WITHOUT TIME ZONE", + SystemColumn::DeleteUserId => "VARCHAR(50)", + } + } + + /// 是否 `NOT NULL`。 + /// + /// Java `TableFeildsEnum` 的 `nullSign`: + /// `FID`/`TENANTID` = "NOT NULL",其余全部 "NULL"。 + fn not_null(self) -> bool { + matches!(self, SystemColumn::TenantId) + } + + /// 是否参与复合主键。 + /// + /// Java `TableFeildsEnum`:只有 `FID` 与 `TENANTID` 的 `primaryKey = true`。 + fn primary_key(self) -> bool { + matches!(self, SystemColumn::TenantId) + } + + /// 默认值字面量。 + /// + /// Java `ConcurrencyUtils.getDbFieldModel()`: + /// ```java + /// if (TENANTID.equals(...) || FLOWSTATE.equals(...) || VERSION.equals(...)) { + /// dbFieldModel.setDefaultValue("0"); + /// } + /// ``` + /// + /// Java `FormatSql.defaultCheck()`(**所有类型都加引号**,不区分 varchar/int): + /// ```java + /// String defaultValue = "'" + fieldModel.getDefaultValue() + "'"; + /// return "DEFAULT " + defaultValue; + /// ``` + /// ⇒ 统一用 `'0'`(带引号)。PG 里 `INTEGER DEFAULT '0'` 合法 + /// (字符串常量会转成目标类型),与 Java 输出**逐字一致**。 + /// + /// ## 🔴 与官方手写 DDL 的差异 + /// + /// 官方 `jnpf_db_init.sql` 里 `f_version INTEGER` / `f_flow_state INTEGER` + /// **没有 DEFAULT** —— 那是**手写**的基线脚本,不是 Java 动态建表的产物。 + /// 本模块生成的是「Java 动态建表」的结果 ⇒ 带 DEFAULT。 + /// 差异已记录在 `docs/visualdev-mechanism.md`。 + fn default_literal(self) -> Option { + match self { + SystemColumn::TenantId + | SystemColumn::FlowState + | SystemColumn::Version => Some("'0'".to_string()), + _ => None, + } + } + + /// 注释。 + fn comment(self) -> &'static str { + match self { + SystemColumn::TenantId => "租户id", + SystemColumn::FlowId => "流程id", + SystemColumn::Version => "乐观锁", + SystemColumn::FlowTaskId => "流程任务主键", + SystemColumn::FlowState => "流程任务状态", + SystemColumn::DeleteMark => "删除标志", + SystemColumn::DeleteTime => "删除时间", + SystemColumn::DeleteUserId => "删除用户", + } + } + + /// 转成列定义。 + fn to_column(self) -> ColumnDdl { + ColumnDdl { + name: self.name().to_string(), + sql_type: self.sql_type().to_string(), + not_null: self.not_null(), + default: self.default_literal(), + primary_key: self.primary_key(), + comment: Some(self.comment().to_string()), + model_field: self.name().to_string(), + model_data_type: self.view_type().to_string(), + model_data_length: self.view_length(), + } + } + + /// 回写模型时用的**视图类型**(JNPF `DtViewConst`)。 + /// + /// 🔴 官方数据的口径: + /// - `f_version` / `f_flow_state` / `f_delete_mark` → `"int"`; + /// - `f_tenant_id` / `f_flow_id` / `f_flow_task_id` → `"varchar"`; + /// - `f_delete_time` → `"datetime"`。 + fn view_type(self) -> &'static str { + match self { + SystemColumn::TenantId + | SystemColumn::FlowId + | SystemColumn::FlowTaskId + | SystemColumn::DeleteUserId => "varchar", + SystemColumn::Version | SystemColumn::FlowState | SystemColumn::DeleteMark => "int", + SystemColumn::DeleteTime => "datetime", + } + } + + /// 回写模型时用的 `dataLength`。 + /// + /// 🔴 官方数据的口径:**只有 `varchar` 有长度**,其余一律 `null`。 + /// (`f_delete_mark` 是 `int` ⇒ `dataLength: null`,与官方数据一致。) + fn view_length(self) -> Option { + match self { + SystemColumn::TenantId + | SystemColumn::FlowId + | SystemColumn::FlowTaskId + | SystemColumn::DeleteUserId => Some("50".to_string()), + _ => None, + } + } +} + +/// 追加一个系统列(已存在则跳过 —— 不报错)。 +fn add_system_column( + columns: &mut Vec, + seen: &mut BTreeMap, + sys_col: SystemColumn, +) { + let name = sys_col.name().to_string(); + if seen.contains_key(&name) { + // 模型里已经有同名列(官方 fixture 就是这样:模型里已含 + // `f_tenant_id` / `f_flow_id` / …)⇒ 保留模型那一份,不重复追加。 + return; + } + seen.insert(name.clone(), ()); + columns.push(sys_col.to_column()); +} + +/// 🔴 数据类型映射(模型 `dataType` ⇒ PostgreSQL)。 +/// +/// ## 溯源 +/// +/// Java `DtPostgreSQLEnum` + `DtViewConst`: +/// +/// | 模型 `dataType` | PostgreSQL | 官方 DDL 佐证 | +/// |---|---|---| +/// | `varchar` | `VARCHAR(n)` | `f_id VARCHAR(50)` | +/// | `int` / `int4` | `INTEGER` | `f_enabledmark INTEGER` | +/// | `bigint` / `int8` | `BIGINT` | `f_sort_code BIGINT` | +/// | `decimal` / `numeric` | `DECIMAL(p, s)` | `f_rent DECIMAL(18, 2)` | +/// | `datetime` / `timestamp` | `TIMESTAMP(0) WITHOUT TIME ZONE` | `f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE` | +/// | `text` | `TEXT` | `f_tables_data TEXT` | +/// | `bool` / `boolean` | `BOOLEAN` | — | +/// +/// ## 🔴 精度标度从哪来 +/// +/// 官方模型里 `dataLength` 就是 `"18,2"` ⇒ 直接用。 +/// 但模型的 `dataLength` 有时是 `null`(如 `bigint` 的 `f_sort_code`), +/// 这时要**按类型给默认值**,而不是报错: +/// +/// | 类型 | 默认 | +/// |---|---| +/// | `varchar` | `50`(Java `TableFeildsEnum.FID` 的默认长度) | +/// | `decimal` | `18,2`(官方 `test_details` 的形态) | +/// | `datetime` | 无长度 | +fn map_type( + table: &str, + column: &str, + data_type: &str, + data_length: &str, +) -> Result { + let t = data_type.trim().to_lowercase(); + let len = data_length.trim(); + + match t.as_str() { + "varchar" | "string" | "char" | "character" => { + let n = parse_len_or(len, 50).ok_or_else(|| DdlError::InvalidLength { + table: table.to_string(), + column: column.to_string(), + length: len.to_string(), + })?; + Ok(TypeSpec { + sql_type: format!("VARCHAR({n})"), + view_type: "varchar".to_string(), + length: Some(n.to_string()), + }) + } + "text" => Ok(TypeSpec { + sql_type: "TEXT".to_string(), + view_type: "text".to_string(), + length: None, + }), + "int" | "int4" | "integer" | "smallint" | "int2" => Ok(TypeSpec { + sql_type: "INTEGER".to_string(), + view_type: "int".to_string(), + length: None, + }), + "bigint" | "int8" => Ok(TypeSpec { + sql_type: "BIGINT".to_string(), + view_type: "bigint".to_string(), + length: None, + }), + "decimal" | "numeric" => { + let spec = if len.is_empty() { + "18,2".to_string() + } else { + len.to_string() + }; + let (p, s) = spec.split_once(',').unwrap_or((spec.as_str(), "0")); + let p: u32 = p + .trim() + .parse() + .map_err(|_| DdlError::InvalidLength { + table: table.to_string(), + column: column.to_string(), + length: spec.clone(), + })?; + let s: u32 = s + .trim() + .parse() + .map_err(|_| DdlError::InvalidLength { + table: table.to_string(), + column: column.to_string(), + length: spec.clone(), + })?; + if p == 0 || p > 1000 || s > p { + return Err(DdlError::InvalidLength { + table: table.to_string(), + column: column.to_string(), + length: spec, + }); + } + Ok(TypeSpec { + sql_type: format!("DECIMAL({p}, {s})"), + view_type: "decimal".to_string(), + length: Some(format!("{p},{s}")), + }) + } + "datetime" | "timestamp" | "date" => Ok(TypeSpec { + sql_type: "TIMESTAMP(0) WITHOUT TIME ZONE".to_string(), + view_type: "datetime".to_string(), + length: None, + }), + "bool" | "boolean" => Ok(TypeSpec { + sql_type: "BOOLEAN".to_string(), + view_type: "bool".to_string(), + length: None, + }), + "float" | "real" | "double" => Ok(TypeSpec { + sql_type: "DOUBLE PRECISION".to_string(), + view_type: "double".to_string(), + length: None, + }), + "" => Err(DdlError::UnsupportedType { + table: table.to_string(), + column: column.to_string(), + data_type: "(空)".to_string(), + }), + other => Err(DdlError::UnsupportedType { + table: table.to_string(), + column: column.to_string(), + data_type: other.to_string(), + }), + } +} + +/// 一个类型的三个面:PG 类型片段、JNPF 视图类型、模型里的长度。 +/// +/// ## 🔴 为什么要拆成三个 +/// +/// JNPF 的 `f_tables_data` 里 `dataType` 是**视图类型** +/// (`DtViewConst.VARCHAR` = `"varchar"`、`DATE_TIME` = `"datetime"` …), +/// 而 DDL 用的是 PG 类型片段(`VARCHAR(50)` / `TIMESTAMP(0) WITHOUT TIME ZONE`)。 +/// 回写模型时要写**视图类型**,建表时要写 **PG 类型** —— 两者不能混。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TypeSpec { + /// PG 类型片段。 + pub sql_type: String, + /// JNPF 视图类型(回写 `f_tables_data.dataType` 用)。 + pub view_type: String, + /// 长度(`varchar` → `"50"`;`decimal` → `"18,2"`;其余 `None`)。 + pub length: Option, +} + +/// 解析长度(正整数)。 +fn parse_len_or(len: &str, default: u32) -> Option { + if len.is_empty() { + return Some(default); + } + len.parse::().ok().filter(|n| *n > 0) +} + +/// 转义 SQL 字符串字面量里的单引号。 +fn escape_literal(s: &str) -> String { + s.replace('\'', "''") +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + /// 官方 fixture 的模型(`tests/fixtures/sample_model.json` 的等价物)。 + const OFFICIAL_MODEL: &str = r#"[ + { + "table": "test_receivable", "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_Userid", "fieldName": "对接人", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }, + { "field": "F_Phone", "fieldName": "联系方式", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }, + { "field": "F_Ost", "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_flowtaskid", "fieldName": "流程任务主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }, + { "field": "f_flow_id", "fieldName": "流程id", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }, + { "field": "f_flow_task_id", "fieldName": "流程任务主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }, + { "field": "f_inte_assistant", "fieldName": "助手", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }, + { "field": "f_flow_state", "fieldName": "流程任务状态", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 } + ] + }, + { + "table": "test_details", "tableName": "应收费用明细表", "typeId": "0", + "tableField": "F_Receivableid", "relationField": "F_Id", "relationTable": "test_receivable", + "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_Water_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 model() -> ModelSchema { + ModelSchema::from_str(OFFICIAL_MODEL).expect("模型应可解析") + } + + fn opts() -> DdlOptions { + DdlOptions::default_options() + } + + /// 🔴 **主表 DDL 必须与官方真实 DDL 同形**。 + /// + /// 官方 `jnpf_db_init.sql`: + /// ```sql + /// CREATE TABLE test_receivable ( + /// f_id VARCHAR(50) NOT NULL, + /// f_building VARCHAR(100), + /// ... + /// f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + /// f_version INTEGER, + /// f_flowtaskid VARCHAR(50), + /// f_flow_id VARCHAR(50), + /// f_flow_task_id VARCHAR(50), + /// f_inte_assistant INTEGER, + /// f_flow_state INTEGER, + /// PRIMARY KEY (f_id, f_tenant_id) + /// ); + /// ``` + #[test] + fn main_table_matches_official_ddl_shape() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let sql = plan.main.render(); + + assert!(sql.starts_with("CREATE TABLE test_receivable ("), "{sql}"); + assert!(sql.contains("f_id VARCHAR(50) NOT NULL"), "{sql}"); + assert!(sql.contains("f_building VARCHAR(100)"), "{sql}"); + assert!(sql.contains("f_room VARCHAR(100)"), "{sql}"); + assert!(sql.contains("f_company_name VARCHAR(50)"), "{sql}"); + assert!(sql.contains("f_sort_code BIGINT"), "{sql}"); + assert!(sql.contains("f_enabledmark INTEGER"), "{sql}"); + assert!( + sql.contains("f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE"), + "{sql}" + ); + assert!(sql.contains("f_creatoruserid VARCHAR(50)"), "{sql}"); + assert!( + sql.contains("f_lastmodifytime TIMESTAMP(0) WITHOUT TIME ZONE"), + "{sql}" + ); + assert!( + sql.contains("f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL"), + "租户列应带 NOT NULL + 默认 '0': {sql}" + ); + assert!(sql.contains("f_version INTEGER"), "{sql}"); + assert!(sql.contains("f_flowtaskid VARCHAR(50)"), "{sql}"); + assert!(sql.contains("f_flow_id VARCHAR(50)"), "{sql}"); + assert!(sql.contains("f_flow_task_id VARCHAR(50)"), "{sql}"); + assert!(sql.contains("f_inte_assistant INTEGER"), "{sql}"); + assert!(sql.contains("f_flow_state INTEGER"), "{sql}"); + assert!( + sql.contains("PRIMARY KEY (f_id, f_tenant_id)"), + "🔴 主键必须是复合的: {sql}" + ); + assert!(sql.ends_with(");"), "{sql}"); + } + + /// 🔴 **子表 DDL 必须与官方真实 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_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_matches_official_ddl_shape() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + assert_eq!(plan.subs.len(), 1); + let sql = plan.subs[0].render(); + + assert!(sql.starts_with("CREATE TABLE test_details ("), "{sql}"); + assert!(sql.contains("f_id VARCHAR(50) NOT NULL"), "{sql}"); + assert!( + sql.contains("f_receivableid VARCHAR(50)"), + "🔴 子表外键应按模型的 tableField 推导: {sql}" + ); + assert!( + !sql.contains("f_foreign_id"), + "🔴 官方真实表没有 f_foreign_id 列: {sql}" + ); + assert!(sql.contains("f_month VARCHAR(200)"), "{sql}"); + assert!(sql.contains("f_rent DECIMAL(18, 2)"), "{sql}"); + assert!( + sql.contains("f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE"), + "{sql}" + ); + assert!(sql.contains("f_creatoruserid VARCHAR(50)"), "{sql}"); + assert!( + sql.contains("f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL"), + "{sql}" + ); + assert!(sql.contains("PRIMARY KEY (f_id, f_tenant_id)"), "{sql}"); + } + + /// 🔴 子表**没有**流程/并发列(Java 只给主表加)。 + #[test] + fn sub_table_has_no_flow_columns() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let sql = plan.subs[0].render(); + assert!(!sql.contains("f_flow_id"), "子表不该有 f_flow_id: {sql}"); + assert!(!sql.contains("f_version"), "子表不该有 f_version: {sql}"); + assert!(!sql.contains("f_flow_state"), "子表不该有 f_flow_state: {sql}"); + } + + /// 🔴 逻辑删除列**主表与子表同进同退**。 + #[test] + fn logical_delete_columns_appear_in_both_tables() { + let mut o = opts(); + o.logical_delete = true; + let plan = plan_create(&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}"); + } + } + + /// 🔴 `logical_delete = false` ⇒ **没有**删除列(官方 `test_receivable` 就是这样)。 + #[test] + fn no_logical_delete_means_no_delete_columns() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let sql = plan.main.render(); + assert!(!sql.contains("f_delete_mark"), "{sql}"); + assert!(!sql.contains("f_delete_time"), "{sql}"); + assert!(!sql.contains("f_delete_user_id"), "{sql}"); + } + + /// 🔴 删标记列是 **INTEGER** 不是 boolean(官方真实 DDL + Java `TableFeildsEnum`)。 + #[test] + fn delete_mark_is_integer_not_boolean() { + let mut o = opts(); + o.logical_delete = true; + let plan = plan_create(&model(), &o).expect("应能生成建表计划"); + let sql = plan.main.render(); + assert!( + sql.contains("f_delete_mark INTEGER"), + "🔴 删除标记必须是 INTEGER(JNPF 写的是 = 1): {sql}" + ); + assert!(!sql.contains("BOOLEAN"), "{sql}"); + } + + /// 🔴 表名非法必须报错,不能拼进 SQL。 + #[test] + fn illegal_table_name_is_rejected() { + let m = ModelSchema::parse(&json!([ + { "table": "bad; DROP TABLE x", "typeId": "1", "fields": [ + { "field": "F_Id", "dataType": "varchar", "primaryKey": 1 } + ]} + ])) + .unwrap(); + let err = plan_create(&m, &opts()).expect_err("非法表名必须被拒"); + assert_eq!(err.code(), "ILLEGAL_IDENTIFIER"); + } + + /// 🔴 类型不认识必须报错,**不降级成 varchar**。 + #[test] + fn unknown_type_is_rejected_not_downgraded() { + let m = ModelSchema::parse(&json!([ + { "table": "t_x", "typeId": "1", "fields": [ + { "field": "F_Id", "dataType": "varchar", "primaryKey": 1 }, + { "field": "F_Weird", "dataType": "geometry", "dataLength": "10" } + ]} + ])) + .unwrap(); + let err = plan_create(&m, &opts()).expect_err("未知类型必须被拒"); + assert_eq!(err.code(), "UNSUPPORTED_TYPE"); + assert!(err.message().contains("不会静默降级"), "{}", err.message()); + } + + /// 🔴 没有主表 ⇒ 报错。 + #[test] + fn missing_main_table_is_rejected() { + let m = ModelSchema::parse(&json!([ + { "table": "t_child", "typeId": "0", "fields": [ + { "field": "F_Id", "dataType": "varchar", "primaryKey": 1 } + ]} + ])) + .unwrap(); + let err = plan_create(&m, &opts()).expect_err("没有主表必须被拒"); + assert_eq!(err.code(), "NO_MAIN_TABLE"); + } + + /// 🔴 子表没有 `tableField` ⇒ 外键列无从推导 ⇒ 报错。 + #[test] + fn sub_table_without_table_field_is_rejected() { + let m = ModelSchema::parse(&json!([ + { "table": "t_main", "typeId": "1", "fields": [ + { "field": "F_Id", "dataType": "varchar", "primaryKey": 1 } + ]}, + { "table": "t_sub", "typeId": "0", "fields": [ + { "field": "F_Id", "dataType": "varchar", "primaryKey": 1 } + ]} + ])) + .unwrap(); + let err = plan_create(&m, &opts()).expect_err("缺 tableField 必须被拒"); + assert_eq!(err.code(), "UNSUPPORTED_TYPE"); + } + + /// 🔴 系统列**不重复**追加(模型里已含 `f_tenant_id` 等)。 + #[test] + fn system_columns_are_not_duplicated() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let names = plan.main.column_names(); + let mut count = 0; + for n in &names { + if n == "f_tenant_id" { + count += 1; + } + } + assert_eq!(count, 1, "f_tenant_id 只能出现一次: {names:?}"); + assert_eq!( + names.iter().filter(|n| *n == "f_id").count(), + 1, + "f_id 只能出现一次: {names:?}" + ); + } + + /// 🔴 主表列顺序 = 官方顺序(业务列在前,系统列在后)。 + #[test] + fn column_order_follows_official_layout() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let names = plan.main.column_names(); + assert_eq!(names[0], "f_id"); + assert_eq!(names[1], "f_building"); + // 租户列在业务列之后 + let tenant = names.iter().position(|n| n == "f_tenant_id").unwrap(); + let business = names.iter().position(|n| n == "f_building").unwrap(); + assert!(tenant > business, "{names:?}"); + } + + /// 🔴 自增主键策略(`primaryKeyPolicy = 2`)⇒ PG 用 `SERIAL`。 + #[test] + fn auto_increment_primary_key_uses_serial() { + let mut o = opts(); + o.primary_key_policy = 2; + let plan = plan_create(&model(), &o).expect("应能生成建表计划"); + assert!(plan.main.render().contains("f_id SERIAL NOT NULL")); + } + + /// 注释语句可选生成。 + #[test] + fn comments_are_optional() { + let mut o = opts(); + o.with_comments = true; + let plan = plan_create(&model(), &o).expect("应能生成建表计划"); + let comments = plan.main.render_comments(); + assert!(!comments.is_empty()); + assert!( + comments.iter().any(|c| c.contains("COMMENT ON TABLE test_receivable")), + "{comments:?}" + ); + assert!( + comments.iter().any(|c| c.contains("COMMENT ON COLUMN test_receivable.f_id")), + "{comments:?}" + ); + } + + /// 类型映射全表覆盖 —— **PG 类型片段**。 + #[test] + fn type_mapping_covers_official_types() { + let sql = |t: &str, l: &str| map_type("t", "c", t, l).unwrap().sql_type; + assert_eq!(sql("varchar", "50"), "VARCHAR(50)"); + assert_eq!(sql("text", ""), "TEXT"); + assert_eq!(sql("int", ""), "INTEGER"); + assert_eq!(sql("int4", ""), "INTEGER"); + assert_eq!(sql("bigint", ""), "BIGINT"); + assert_eq!(sql("decimal", "18,2"), "DECIMAL(18, 2)"); + assert_eq!( + sql("datetime", ""), + "TIMESTAMP(0) WITHOUT TIME ZONE" + ); + assert_eq!(sql("bool", ""), "BOOLEAN"); + } + + /// 🔴 视图类型(回写 `f_tables_data.dataType` 用)必须与官方数据一致。 + #[test] + fn view_types_match_official_data() { + let view = |t: &str, l: &str| map_type("t", "c", t, l).unwrap().view_type; + assert_eq!(view("varchar", "50"), "varchar"); + assert_eq!(view("text", ""), "text"); + assert_eq!(view("int", ""), "int"); + assert_eq!(view("int4", ""), "int"); + assert_eq!(view("bigint", ""), "bigint"); + assert_eq!(view("decimal", "18,2"), "decimal"); + assert_eq!(view("datetime", ""), "datetime"); + assert_eq!(view("bool", ""), "bool"); + } + + /// 🔴 `dataLength` 口径:**只有 `varchar` / `decimal` 有长度**,其余 `null`。 + /// + /// 官方真实数据: + /// ```json + /// {"dataType":"int", "dataLength":null, "field":"f_delete_mark"} + /// {"dataType":"varchar","dataLength":"50","field":"f_tenant_id"} + /// ``` + #[test] + fn data_length_only_for_varchar_and_decimal() { + let len = |t: &str, l: &str| map_type("t", "c", t, l).unwrap().length; + assert_eq!(len("varchar", "50"), Some("50".to_string())); + assert_eq!(len("decimal", "18,2"), Some("18,2".to_string())); + assert_eq!(len("int", ""), None); + assert_eq!(len("bigint", ""), None); + assert_eq!(len("datetime", ""), None); + assert_eq!(len("text", ""), None); + } + + /// 长度缺失时按类型给默认值(不报错)。 + #[test] + fn missing_length_uses_type_default() { + assert_eq!( + map_type("t", "c", "varchar", "").unwrap().sql_type, + "VARCHAR(50)" + ); + assert_eq!( + map_type("t", "c", "decimal", "").unwrap().sql_type, + "DECIMAL(18, 2)" + ); + } + + /// 非法长度必须报错。 + #[test] + fn invalid_length_is_rejected() { + assert_eq!( + map_type("t", "c", "varchar", "abc").unwrap_err().code(), + "INVALID_LENGTH" + ); + assert_eq!( + map_type("t", "c", "decimal", "0,2").unwrap_err().code(), + "INVALID_LENGTH" + ); + } + + // ============================================================ + // 🔴 回写模型(`rewrite_model`) + // ============================================================ + + /// 🔴 回写后的模型必须**含系统列** —— 这正是 JNPF 建表后做的事。 + /// + /// 不回写 ⇒ CRUD 层在模型里找不到 `f_delete_mark` ⇒ 逻辑删除报 + /// `LOGICAL_DELETE_UNSUPPORTED`(本项目已真实踩到)。 + #[test] + fn rewritten_model_contains_system_columns() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let rewritten = rewrite_model(&model(), &plan); + let m = ModelSchema::parse(&rewritten).expect("回写的模型应可解析"); + + let main = m.main_table().unwrap(); + let names = main.column_names(); + for want in [ + "f_id", + "f_tenant_id", + "f_version", + "f_flow_id", + "f_flow_task_id", + "f_flow_state", + ] { + assert!(names.contains(&want.to_string()), "回写后模型缺 {want}: {names:?}"); + } + + // 子表也要有租户列,但**没有**流程列 + let sub = m.sub_tables()[0]; + let sub_names = sub.column_names(); + assert!(sub_names.contains(&"f_tenant_id".to_string()), "{sub_names:?}"); + assert!(!sub_names.contains(&"f_flow_state".to_string()), "{sub_names:?}"); + } + + /// 🔴 逻辑删除开启 ⇒ 回写模型里要有**三个**删除列。 + #[test] + fn rewritten_model_contains_delete_columns_when_logical() { + let mut o = opts(); + o.logical_delete = true; + let plan = plan_create(&model(), &o).expect("应能生成建表计划"); + let rewritten = rewrite_model(&model(), &plan); + let m = ModelSchema::parse(&rewritten).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 + ); + } + } + } + + /// 🔴 回写后的字段对象形态必须与**官方真实数据**一致。 + /// + /// 官方: + /// ```json + /// {"allowNull":1,"autoIncrement":0,"columnName":null,"dataLength":"50", + /// "dataType":"varchar","dataTypeName":null,"dataTypeReal":null, + /// "field":"F_Room","fieldName":"房间号","identity":0,"primaryKey":0} + /// ``` + #[test] + fn rewritten_field_objects_match_official_shape() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let rewritten = rewrite_model(&model(), &plan); + let main = rewritten[0].as_object().unwrap(); + let fields = main["fields"].as_array().unwrap(); + + // 找 F_Room + let room = fields + .iter() + .find(|f| f["field"] == "F_Room") + .expect("应有 F_Room"); + assert_eq!(room["allowNull"], json!(1)); + assert_eq!(room["autoIncrement"], json!(0)); + assert_eq!(room["columnName"], json!(null)); + assert_eq!(room["dataLength"], json!("100")); + assert_eq!(room["dataType"], json!("varchar")); + assert_eq!(room["dataTypeName"], json!(null)); + assert_eq!(room["dataTypeReal"], json!(null)); + assert_eq!(room["fieldName"], json!("房间号")); + assert_eq!(room["identity"], json!(0)); + assert_eq!(room["primaryKey"], json!(0)); + + // f_delete_mark(逻辑删除关闭时不该有)—— 这里测 f_version + let ver = fields + .iter() + .find(|f| f["field"] == "f_version") + .expect("应有 f_version"); + assert_eq!(ver["dataType"], json!("int")); + assert_eq!(ver["dataLength"], json!(null), "int 类型不该有长度"); + assert_eq!(ver["primaryKey"], json!(0)); + + // 租户列:varchar + 长度 50 + 主键 + let tenant = fields + .iter() + .find(|f| f["field"] == "f_tenant_id") + .expect("应有 f_tenant_id"); + assert_eq!(tenant["dataType"], json!("varchar")); + assert_eq!(tenant["dataLength"], json!("50")); + assert_eq!(tenant["primaryKey"], json!(1)); + assert_eq!(tenant["allowNull"], json!(0)); + } + + /// 🔴 主键列在回写后仍标 `primaryKey = 1`。 + #[test] + fn rewritten_model_keeps_composite_primary_key() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let rewritten = rewrite_model(&model(), &plan); + let m = ModelSchema::parse(&rewritten).expect("回写的模型应可解析"); + assert_eq!( + m.main_table().unwrap().primary_keys(), + vec!["f_id".to_string(), "f_tenant_id".to_string()] + ); + } + + /// 🔴 子表的 `tableField` / `relationField` / `relationTable` 要回写对。 + #[test] + fn rewritten_sub_table_keeps_relation_fields() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let rewritten = rewrite_model(&model(), &plan); + let sub = rewritten[1].as_object().unwrap(); + + assert_eq!(sub["typeId"], json!("0")); + assert_eq!(sub["tableField"], json!("F_Receivableid")); + assert_eq!(sub["relationField"], json!("F_Id")); + assert_eq!(sub["relationTable"], json!("test_receivable")); + assert_eq!(sub["comment"], json!("子表")); + + // 主表三项是空串 + let main = rewritten[0].as_object().unwrap(); + assert_eq!(main["typeId"], json!("1")); + assert_eq!(main["tableField"], json!("")); + assert_eq!(main["relationField"], json!("")); + assert_eq!(main["relationTable"], json!("")); + assert_eq!(main["comment"], json!("主表")); + } + + /// 🔴 回写是**幂等**的:回写后再回写,结果不变。 + /// + /// 幂等很重要 —— 建表流程可能被重跑(幂等建表 + 幂等回写)。 + #[test] + fn rewrite_model_is_idempotent() { + let plan = plan_create(&model(), &opts()).expect("应能生成建表计划"); + let once = rewrite_model(&model(), &plan); + let m1 = ModelSchema::parse(&once).unwrap(); + let plan2 = plan_create(&m1, &opts()).expect("二次建表计划应可生成"); + let twice = rewrite_model(&m1, &plan2); + let m2 = ModelSchema::parse(&twice).unwrap(); + + assert_eq!(m1.main_table().unwrap().column_names(), m2.main_table().unwrap().column_names()); + assert_eq!(m1.sub_tables()[0].column_names(), m2.sub_tables()[0].column_names()); + } +} diff --git a/crates/sspf-lowcode/src/form.rs b/crates/sspf-lowcode/src/form.rs index 63590e0..a3e7863 100644 --- a/crates/sspf-lowcode/src/form.rs +++ b/crates/sspf-lowcode/src/form.rs @@ -103,8 +103,31 @@ pub struct FieldNode { pub layout: String, /// 该控件所属物理表(`__config__.tableName`)。 pub table_name: Option, + /// 该控件关联的物理表(`__config__.relationTable`)。 + /// + /// 🔴 **只对子表里的字段有意义**:实测子表字段的 `tableName` 指向**主表** + /// (方言陷阱),但 `relationTable` 指向**子表自己** —— 它是「这个字段属于 + /// 哪张表」唯一可信的线索。没有它,动态 CRUD 只能靠「取第一个非主表」来猜, + /// 多子表时会把数据串到错的表里。 + pub relation_table: Option, /// 是否必填。 pub required: bool, + /// 🔴 是否**单行唯一**(`__config__.unique`)。 + /// + /// 基线平台 `ConfigModel`: + /// ```java + /// //是否唯一 + /// private Boolean unique = false; + /// ``` + /// + /// 基线平台 `FormCheckUtils.checkForm()` 里,**只有 `jnpfKey == "input"`** + /// 且 `unique == true` 的字段才参与唯一性校验: + /// ```java + /// if (JnpfKeyConsts.COM_INPUT.equals(config.getJnpfKey()) + /// && Boolean.TRUE.equals(config.getUnique())) { ... } + /// ``` + /// ⇒ 这里保留 `jnpf_key` 一起判断,别把「唯一」当成通用能力。 + pub unique: bool, /// 可见端:`["pc"]` / `["pc","app"]`。 pub visibility: Vec, /// 是否隐藏(`noShow`)。 @@ -200,6 +223,23 @@ pub struct FormSchema { pub concurrency_lock: Option, /// 是否逻辑删除(`logicalDelete`)。 pub logical_delete: Option, + /// 🔴 是否启用**业务主键**(`useBusinessKey`)。 + /// + /// 基线平台 `FormDataModel`: + /// ```java + /// //业务主键属性 + /// private boolean useBusinessKey; + /// private String[] businessKeyList; + /// private String businessKeyTip; + /// ``` + pub use_business_key: bool, + /// 🔴 业务主键字段清单(`businessKeyList`,存的是 `__vModel__`)。 + /// + /// 语义:这几个字段的**组合**在表里必须唯一(基线平台 + /// `FormCheckUtils.checkBusinessKey()`)。全为空 ⇒ 不校验。 + pub business_key_list: Vec, + /// 业务主键重复时的提示语(`businessKeyTip`)。 + pub business_key_tip: Option, /// 顶层控件树。 pub fields: Vec, } @@ -228,6 +268,21 @@ impl FormSchema { primary_key_policy: obj.get("primaryKeyPolicy").and_then(Value::as_i64), concurrency_lock: obj.get("concurrencyLock").and_then(Value::as_bool), logical_delete: obj.get("logicalDelete").and_then(Value::as_bool), + use_business_key: obj.get("useBusinessKey").and_then(Value::as_bool).unwrap_or(false), + business_key_list: obj + .get("businessKeyList") + .and_then(Value::as_array) + .map(|a| { + a.iter() + .filter_map(Value::as_str) + .map(str::to_string) + .collect() + }) + .unwrap_or_default(), + business_key_tip: obj + .get("businessKeyTip") + .and_then(Value::as_str) + .map(str::to_string), fields, }) } @@ -270,6 +325,61 @@ impl FormSchema { .collect() } + /// 🔴 参与**单行唯一性**校验的字段。 + /// + /// 基线平台 `FormCheckUtils.checkForm()` 的条件是**两个都要满足**: + /// ```java + /// if (JnpfKeyConsts.COM_INPUT.equals(config.getJnpfKey()) + /// && Boolean.TRUE.equals(config.getUnique())) { ... } + /// ``` + /// - `JnpfKeyConsts.COM_INPUT` = `"input"`(普通单行输入框); + /// - `config.getUnique()` = `true`。 + /// + /// ⇒ **不是**「所有标了 unique 的字段」,而是「标了 unique **且**是 input 的字段」。 + /// 下拉/日期/数字等控件即使标了 unique,基线平台**也不查** —— + /// 照抄这个口径,别查多了(查多了会拦住基线平台允许的写入)。 + pub fn unique_fields(&self) -> Vec<&FieldNode> { + self.all_nodes() + .into_iter() + .filter(|n| n.unique && n.jnpf_key == "input" && !n.v_model.is_empty()) + .collect() + } + + /// 🔴 业务主键字段(`useBusinessKey` 开启时的 `businessKeyList`)。 + /// + /// 基线平台 `FormCheckUtils.checkBusinessKey()`: + /// ```java + /// if (formData.isUseBusinessKey()) { + /// List businessKeyList = Arrays.asList(formData.getBusinessKeyList()); + /// if (CollectionUtils.isEmpty(businessKeyList)) { return null; } + /// ... + /// for (String fieldName : businessKeyList) { setEachCondition(...); } + /// } + /// ``` + /// ⇒ 清单里存的是 `__vModel__`;**空值字段用 `IS NULL` 参与比较**。 + /// 返回 `None` 表示「不校验业务主键」。 + pub fn business_key_fields(&self) -> Option> { + if !self.use_business_key || self.business_key_list.is_empty() { + return None; + } + let mut out = Vec::new(); + for vm in &self.business_key_list { + if let Some(node) = self + .all_nodes() + .into_iter() + .find(|n| &n.v_model == vm && !n.is_container()) + { + out.push(node); + } + } + // 清单里的字段一个都找不到 ⇒ 没法校验(不静默跳过) + if out.is_empty() { + None + } else { + Some(out) + } + } + /// 主表字段对应的物理列名(去重、保序)。 pub fn main_columns(&self) -> Vec { let mut out: Vec = Vec::new(); @@ -399,7 +509,12 @@ fn parse_node(v: &Value) -> Option { widget, layout, table_name: cfg.get("tableName").and_then(Value::as_str).map(str::to_string), + relation_table: cfg + .get("relationTable") + .and_then(Value::as_str) + .map(str::to_string), required: cfg.get("required").and_then(Value::as_bool).unwrap_or(false), + unique: cfg.get("unique").and_then(Value::as_bool).unwrap_or(false), visibility, no_show: cfg.get("noShow").and_then(Value::as_bool).unwrap_or(false), form_id: cfg.get("formId").and_then(Value::as_i64), diff --git a/crates/sspf-lowcode/src/lib.rs b/crates/sspf-lowcode/src/lib.rs index 2180e11..968149b 100644 --- a/crates/sspf-lowcode/src/lib.rs +++ b/crates/sspf-lowcode/src/lib.rs @@ -35,19 +35,40 @@ //! 3. `rowFormItem` 是布局容器,不占列,孩子才占 //! 4. `table` 是子表,它的字段属于**另一张物理表** //! +//! ## 模块地图 +//! +//! | 模块 | 职责 | +//! |---|---| +//! | [`form`] | 控件树解析(`FormSchema` / `FieldNode`) | +//! | [`model`] | 表结构解析(`ModelSchema` / `TableSchema`) | +//! | [`widget`] | 54 种 `jnpfKey` → 类别 + 自动填充策略 | +//! | [`validate`] | 表单 ↔ 模型 自洽性诊断(9 类诊断码) | +//! | [`sql`] | **动态 CRUD 的 SQL 生成**(纯函数:出 SQL 文本 + 参数,不连库) | +//! | [`ddl`] | **动态建表的 DDL 生成**(纯函数:出 `CREATE TABLE`,不连库) | +//! //! ## 为什么「不改一个字段」是可验证的 //! //! [`FormSchema::raw`] / [`ModelSchema::raw`] 保留原始 JSON 一字不动, //! 保存时原样写回。解析结果只是**只读视图**, //! 测试 `real_sample.rs` 用官方初始化数据里的真表单做基线断言。 +pub mod ddl; pub mod form; pub mod model; +pub mod sql; pub mod validate; pub mod widget; +pub use ddl::{ + plan_create, rewrite_model, ColumnDdl, CreatePlan, DdlError, DdlOptions, TableDdl, TypeSpec, +}; pub use form::{v_model_to_column, FieldNode, FormError, FormSchema}; pub use model::{ColumnDef, ModelError, ModelSchema, TableSchema}; +pub use sql::{ + check_identifier, diff_sub_rows, lookup, plan_delete, plan_hard_delete, plan_insert, + plan_soft_delete, plan_update, plan_update_full, DeletePlan, Sql, SqlError, SqlKind, SubDiff, + SubUpdateContext, SubUpdateOptions, UpdatePlan, WriteContext, WritePlan, +}; pub use validate::{validate, Diagnostic, Report, Severity}; pub use widget::{auto_fill, classify, AutoFill, WidgetKind}; diff --git a/crates/sspf-lowcode/src/model.rs b/crates/sspf-lowcode/src/model.rs index 8d6731c..507fb97 100644 --- a/crates/sspf-lowcode/src/model.rs +++ b/crates/sspf-lowcode/src/model.rs @@ -119,6 +119,27 @@ pub struct TableSchema { pub type_id: String, /// 列定义(顺序即建表顺序)。 pub fields: Vec, + /// 🔴 **子表外键列**(`tableField`)—— 子表里指向主表主键的那一列。 + /// + /// ## 溯源 + /// + /// Java `FlowFormDataUtil.createMastTable()`: + /// ```java + /// String foreignKey = tableModel.getTableField(); + /// GeneralInsertDSL dsl = insertInto(sqlTable).set(sqlTable.column(foreignKey)).toValue(foreignValue); + /// ``` + /// + /// ⇒ 外键列名**来自模型**,不是常量。实测 `test_details` 的 `tableField` 是 + /// `F_Receivableid` ⇒ 物理列 `f_receivableid`,**不是** `f_foreign_id`。 + /// + /// 🔴 之前硬编码 `f_foreign_id` 会在真实数据上直接 `column does not exist`。 + pub table_field: Option, + /// 🔴 **主表关联字段**(`relationField`)—— 主表里被子表外键引用的那一列。 + /// + /// Java:`Object foreignValue = dataNewMap.get(tableModel.getRelationField());` + pub relation_field: Option, + /// 本表关联到的主表名(`relationTable`;主表自身为空串)。 + pub relation_table: Option, } impl TableSchema { @@ -127,6 +148,20 @@ impl TableSchema { self.type_id == "1" } + /// 子表外键列的**物理列名**(`tableField` 推导)。 + pub fn foreign_key_column(&self) -> Option { + self.table_field + .as_deref() + .and_then(crate::form::v_model_to_column) + } + + /// 主表关联列的**物理列名**(`relationField` 推导)。 + pub fn relation_column(&self) -> Option { + self.relation_field + .as_deref() + .and_then(crate::form::v_model_to_column) + } + /// 按 `F_xxx` 风格的设计态字段名找列(大小写不敏感)。 pub fn column_by_field(&self, field: &str) -> Option<&ColumnDef> { self.fields @@ -222,6 +257,10 @@ fn parse_table(v: &Value) -> Option { Some(Value::Number(n)) => n.to_string(), _ => "0".to_string(), }, + // 🔴 官方数据里这三个字段是空串(主表)或具体列名(子表)⇒ 空串视作「没有」。 + table_field: opt_str(obj, "tableField"), + relation_field: opt_str(obj, "relationField"), + relation_table: opt_str(obj, "relationTable"), fields: obj .get("fields") .and_then(Value::as_array) @@ -230,6 +269,15 @@ fn parse_table(v: &Value) -> Option { }) } +/// 取一个非空字符串字段(空串 ⇒ `None`)。 +fn opt_str(obj: &Map, key: &str) -> Option { + obj.get(key) + .and_then(Value::as_str) + .map(str::trim) + .filter(|s| !s.is_empty()) + .map(str::to_string) +} + fn parse_column(v: &Value) -> Option { let obj = v.as_object()?; let field = obj.get("field").and_then(Value::as_str)?.trim().to_string(); diff --git a/crates/sspf-lowcode/src/sql.rs b/crates/sspf-lowcode/src/sql.rs new file mode 100644 index 0000000..d547412 --- /dev/null +++ b/crates/sspf-lowcode/src/sql.rs @@ -0,0 +1,2562 @@ +//! 动态 CRUD 的 SQL 生成(**纯函数**:只产出 SQL 文本 + 参数,不连库)。 +//! +//! ## 为什么 SQL 生成要放在本 crate(而不是内核) +//! +//! 内核连库执行;SQL 生成的**正确性**(列白名单、系统字段、类型转换、父子表顺序) +//! 才是最该被单测覆盖的部分。放在这里 ⇒ +//! - 不用起数据库就能测(毫秒级) +//! - CLI / 离线工具 / 迁移脚本都能复用同一套生成逻辑 +//! - 内核那边只剩「拿到 SQL 就执行」,没有分支逻辑 +//! +//! ## 对齐基线平台的机制 +//! +//! 逐条对齐 `FlowFormDataUtil`(`jnpf-visualdev-base-biz`): +//! +//! | 规则 | 溯源 | +//! |---|---| +//! | 列名 = `lower(vModel)` | `VisualDevTableCre.fieldList()` + PG `toLowerCase()` | +//! | 空串 → NULL | `getInsertDSL()`:`data == null \|\| isEmpty(data.toString())` → `toNull()` | +//! | 空数组 → NULL | `valueToNull()`:空 List → null | +//! | 主表 `f_flow_task_id` = 主键 | `createMast()`:`set(flowTaskId).toValue(mainId.toString())` | +//! | 主键列名取模型里 `primaryKey=1` 的列,否则 `f_id` | `getKey()` | +//! | 子表 `f_foreign_id` = 主表主键 | `createMastTable()` | +//! | 列表值 → JSON 字符串 | `createMast()`:`data instanceof List ? JsonUtil.getObjectToString(data)` | +//! | 系统字段不被入参覆盖 | `create()` 的 switch 分支 | +//! +//! ## 🔴 值一律参数化 +//! +//! 本模块**只输出 SQL 文本与参数数组**,绝不把值拼进 SQL。 +//! 列名与表名走白名单(来自模型定义),值走 `$n` 占位符。 +//! —— 参数化只能防「值注入」,**结构注入必须靠列白名单**,两者都要。 +//! +//! ## 🔴 表名/列名也不是「拼进去就没事」 +//! +//! 表名来自 `f_tables_data`(用户可编辑的 JSON)⇒ 拼进 SQL 前必须过白名单。 +//! 本模块用两道防线: +//! 1. 表名必须**出现在模型定义里**(`UnknownTable` 错误); +//! 2. 列名必须**出现在该表的列定义里**(`UnknownColumn` 错误)。 +//! 两道都过不了的,一律**报错而不是跳过** —— 跳过会让「传错了字段」静默丢数据。 + +use std::collections::BTreeMap; + +use serde_json::Value; + +use crate::form::{FieldNode, FormSchema}; +use crate::model::{ModelSchema, TableSchema}; +use crate::widget::{auto_fill, AutoFill}; + +/// 系统字段的**识别特征**(不是列名!)。 +/// +/// ## 🔴 为什么这里写的是「特征」而不是列名 +/// +/// 上一版这里硬编码了 `f_creator_time` / `f_foreign_id` / `f_delete_mark` …, +/// 看起来很规整,但**在真实数据上会直接撞 `column does not exist`**。 +/// +/// 原因(已核实 jnpf Java 源码 + 官方初始化数据): +/// +/// | 事实 | 证据 | +/// |---|---| +/// | 建表追加的系统列,名字来自**模型里的字段** | `VisualDevTableCre.fieldList()`:`fieldForm.setField(fieLdsModel.getVModel())` | +/// | 主键列 = 模型里 `primaryKey=1` 的字段 | `FlowFormDataUtil.getKey()` | +/// | 流程任务 id 列 = 模型里字段名**含** `f_flow_task_id` 的那个 | `FlowFormDataUtil.getFlowTaskId()` | +/// | 子表外键列 = 模型的 `tableField` | `FlowFormDataUtil.createMastTable()` | +/// +/// 实测 `test_receivable` 的模型里,`F_CreatorTime` 推出的列是 `f_creatortime` +/// (**没有下划线**),而 `f_creator_time` 是平台表 `base_*` 的手写 DDL 风格。 +/// ⇒ 硬编码列名 = 猜 = 静默写错列。 +/// +/// ## 🔴 特征常量取自 Java 源码,**不许自行简化** +/// +/// `TableFieldsNameConst`(`jnpf-common-core`)的真实字面量: +/// ```java +/// F_ID = "f_id"; F_TENANT_ID = "f_tenant_id"; +/// F_VERSION = "f_version"; F_FLOW_TASK_ID = "f_flow_task_id"; +/// F_FLOW_ID = "f_flow_id"; F_DELETE_MARK = "f_delete_mark"; +/// F_DELETE_TIME = "f_delete_time"; F_DELETE_USER_ID = "f_delete_user_id"; +/// F_FOREIGN_ID = "f_foreign_id"; F_FLOW_STATE = "f_flow_state"; +/// ``` +/// +/// Java 的识别用的是 `field.toLowerCase().contains(<常量>)` —— +/// 例如 `getKey()` 过滤 `contains("f_tenant_id")`、 +/// `getFlowTaskId()` 找 `contains("f_flow_task_id")`。 +/// 写成 `"tenantid"` 会**匹配不上** `f_tenant_id`(多了下划线)⇒ 主键会选错列。 +pub mod sys { + /// 主键列的**兜底**名(模型没标主键时用;Java `TableFeildsEnum.FID`)。 + pub const F_ID: &str = "f_id"; + /// 租户列的**识别特征**(Java `TableFeildsEnum.TENANTID`)。 + pub const TENANTID: &str = "f_tenant_id"; + /// 流程任务 id 列的**识别特征**(Java `TableFeildsEnum.FLOWTASKID`)。 + /// + /// 🔴 Java 侧是 `contains`(包含),不是相等。 + pub const FLOWTASKID: &str = "f_flow_task_id"; + /// 版本列的**识别特征**(并发锁开启时写它;Java `TableFeildsEnum.VERSION`)。 + pub const VERSION: &str = "f_version"; + /// 逻辑删除标记列的**识别特征**(Java `TableFeildsEnum.DELETEMARK`)。 + pub const DELETE_MARK: &str = "f_delete_mark"; + /// 逻辑删除时间列的**识别特征**(Java `TableFeildsEnum.DELETETIME`)。 + pub const DELETE_TIME: &str = "f_delete_time"; + /// 逻辑删除人列的**识别特征**(Java `TableFeildsEnum.DELETEUSERID`)。 + pub const DELETE_USER_ID: &str = "f_delete_user_id"; + /// 最后修改时间列的**识别特征**(Java `TableFeildsEnum.LASTMODIFYTIME`)。 + pub const LAST_MODIFY_TIME: &str = "f_last_modify_time"; + /// 最后修改人列的**识别特征**(Java `TableFeildsEnum.LASTMODIFYUSERID`)。 + pub const LAST_MODIFY_USER_ID: &str = "f_last_modify_user_id"; +} + + + +/// 一条待执行的 SQL(文本 + 参数)。 +#[derive(Debug, Clone, PartialEq)] +pub struct Sql { + /// SQL 文本(值全部是 `$1`/`$2` 占位符)。 + pub text: String, + /// 参数值(按占位符顺序)。 + pub params: Vec, + /// 🔴 **占位符 ↔ 列名的一一映射**(`params[i]` 写的是 `param_columns[i]`)。 + /// + /// ## 为什么必须显式带这个 + /// + /// 执行层要给参数加类型 cast(`$n::text::numeric`), + /// 而 cast 取决于**目标列的数据类型** ⇒ 必须知道「`$n` 是哪一列」。 + /// + /// 之前的做法是「按模型里的字段顺序猜」—— + /// `INSERT INTO t (f_id, f_room) ...` 里 `$1` 未必是 `f_id`, + /// 因为**模型字段顺序 ≠ 实际写入列顺序**(系统列、租户列、 + /// 流程任务列都是运行时追加的)。猜错 ⇒ 数值列被当字符串写、 + /// 时间列 cast 不对 ⇒ 静默写脏数据。 + /// + /// ⇒ 列名跟着参数一起生成,执行层不再需要「理解 SQL 怎么拼的」。 + pub param_columns: Vec, + /// 这条 SQL 作用于哪张表(诊断用)。 + pub table: String, + /// 这条 SQL 属于哪一步(诊断 / 日志用)。 + pub kind: SqlKind, +} + +impl Sql { + /// 稳定字符串(诊断输出用)。 + pub fn kind_str(&self) -> &'static str { + self.kind.as_str() + } + + /// 取某个占位符对应的列名(`$1` ⇒ 第 0 个)。 + pub fn column_of(&self, index: usize) -> Option<&str> { + self.param_columns.get(index).map(String::as_str) + } +} + +/// SQL 的语义类别。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SqlKind { + /// 主表新增。 + InsertMain, + /// 子表新增。 + InsertSub, + /// 主表更新。 + UpdateMain, + /// 子表更新。 + UpdateSub, + /// 逻辑删除(置删除标记)。 + SoftDelete, + /// 物理删除(`logicalDelete=false` 时基线平台的行为)。 + HardDelete, +} + +impl SqlKind { + /// 稳定字符串(诊断输出用)。 + pub fn as_str(self) -> &'static str { + match self { + SqlKind::InsertMain => "insertMain", + SqlKind::InsertSub => "insertSub", + SqlKind::UpdateMain => "updateMain", + SqlKind::UpdateSub => "updateSub", + SqlKind::SoftDelete => "softDelete", + SqlKind::HardDelete => "hardDelete", + } + } +} + +/// 生成 SQL 时的错误。 +#[derive(Debug, Clone, PartialEq)] +pub enum SqlError { + /// 表不在模型定义里(⇒ 表名白名单不通过)。 + UnknownTable(String), + /// 列不在模型定义里(⇒ 列名白名单不通过)。 + UnknownColumn { table: String, column: String }, + /// 必填字段没给值。 + MissingRequired { table: String, column: String, label: String }, + /// 主表缺失(模型里没有 `typeId=1` 的表)。 + NoMainTable, + /// 主键缺失且无法自动生成。 + NoPrimaryKey(String), + /// 入参类型不对(该字段要数组却给了标量)。 + TypeMismatch { column: String, expected: &'static str }, + /// 值里含非法类型(对象/数组不能直接入库,除已知可序列化的)。 + UnsupportedValue { column: String }, + /// 表名非法(不是合法 SQL 标识符)。 + IllegalIdentifier { kind: &'static str, value: String }, + /// 更新/删除时**一列都没改** —— 静默执行一条空 UPDATE 等于骗人。 + NoColumnsToUpdate(String), + /// 子表外键指向的主表列,值拿不到。 + /// + /// 🔴 为什么会有这个错:`relationField` 指向的**不一定是主键** + /// (官方 fixture 里恰好是 `F_Id`)。若它指向别的列(如 `F_Code`), + /// 那个值只能来自数据库或入参 —— 本 crate 是纯计算层,查不了库。 + MissingRelationValue { table: String, column: String }, + /// 这张表**不支持逻辑删除**(模型里没有删除标记列)。 + /// + /// ## 🔴 为什么必须报错,而不是「退化成物理删除」 + /// + /// 动态建表时(`VisualDevTableCre`)删除列是**跟着 `logicalDelete` 一起加的** —— + /// 主表和子表要么都有,要么都没有。 + /// ⇒ 「表里没有删除列」只可能是两种情况: + /// 1. 这个功能的 `logicalDelete = false` ⇒ 本来就该物理删(调用方会走物理删路径); + /// 2. 设计稿与真实库不一致(表建错了)⇒ **必须报出来**。 + /// + /// 退化成空 UPDATE = 「什么都没删,但返回成功」—— 比删不掉更糟: + /// 用户以为删了,实际行还在,列表里还查得到。 + LogicalDeleteUnsupported(String), +} + +impl SqlError { + /// 错误码(稳定字符串,便于 AI 自纠)。 + pub fn code(&self) -> &'static str { + match self { + SqlError::UnknownTable(_) => "UNKNOWN_TABLE", + SqlError::UnknownColumn { .. } => "UNKNOWN_COLUMN", + SqlError::MissingRequired { .. } => "MISSING_REQUIRED", + SqlError::NoMainTable => "NO_MAIN_TABLE", + SqlError::NoPrimaryKey(_) => "NO_PRIMARY_KEY", + SqlError::TypeMismatch { .. } => "TYPE_MISMATCH", + SqlError::UnsupportedValue { .. } => "UNSUPPORTED_VALUE", + SqlError::IllegalIdentifier { .. } => "ILLEGAL_IDENTIFIER", + SqlError::NoColumnsToUpdate(_) => "NO_COLUMNS_TO_UPDATE", + SqlError::MissingRelationValue { .. } => "MISSING_RELATION_VALUE", + SqlError::LogicalDeleteUnsupported(_) => "LOGICAL_DELETE_UNSUPPORTED", + } + } + + /// 人话描述。 + pub fn message(&self) -> String { + match self { + SqlError::UnknownTable(t) => { + format!("表 {t} 不在功能定义里(表名白名单不通过)") + } + SqlError::UnknownColumn { table, column } => { + format!("表 {table} 没有列 {column}(列名白名单不通过)") + } + SqlError::MissingRequired { table, column, label } => { + format!("必填字段「{label}」({table}.{column})没给值") + } + SqlError::NoMainTable => "模型里没有主表(typeId=1)".to_string(), + SqlError::NoPrimaryKey(t) => format!("表 {t} 既没标主键,也没给主键值"), + SqlError::TypeMismatch { column, expected } => { + format!("字段 {column} 应为 {expected}") + } + SqlError::UnsupportedValue { column } => { + format!("字段 {column} 的值是复杂对象,无法直接入库") + } + SqlError::IllegalIdentifier { kind, value } => { + format!("{kind}「{value}」不是合法标识符") + } + SqlError::NoColumnsToUpdate(t) => { + format!("表 {t} 没有任何列要更新(入参没给可写字段,或全是系统字段)") + } + SqlError::MissingRelationValue { table, column } => { + format!( + "子表 {table} 的外键指向主表的 {column},但拿不到这一列的值 —— \ + 它不是主键,只能由调用方查出来再传进来" + ) + } + SqlError::LogicalDeleteUnsupported(t) => { + format!( + "表 {t} 没有删除标记列,不支持逻辑删除 —— \ + 这个功能要么该走物理删除,要么表建错了" + ) + } + } + } +} + +/// 写入操作所需的运行时上下文。 +#[derive(Debug, Clone, Default)] +pub struct WriteContext { + /// 当前用户 id(写 `f_creator_user_id` / `f_last_modify_user_id`)。 + pub user_id: Option, + /// 当前用户组织 id 列表(写 `f_curr_organize` 类字段,序列化成 JSON)。 + pub organize_ids: Vec, + /// 当前用户岗位 id 列表。 + pub position_ids: Vec, + /// 租户 id(写 `f_tenant_id`)。 + pub tenant_id: Option, + /// 单据号生成器已产出的值(字段名 → 值)。 + pub bill_numbers: BTreeMap, + /// 主键生成器已产出的值。 + /// + /// ## 🔴 键的约定(唯一,别再猜) + /// + /// | 键 | 含义 | + /// |---|---| + /// | `<表名>` | 该表**主表行**的主键值 | + /// | `<表名>#<主键>` | 该表**首行**的主键值(子表用) | + /// | `<表名>#<主键>#<行号>` | 该表**第 n 行**的主键值(子表多行用,行号从 0 起) | + /// + /// 查键顺序:`<表名>#<主键>#<行号>` → `<表名>#<主键>` → 入参里显式给的值。 + /// + /// Java 侧子表主键是**服务端现生成**的(`RandomUtil.uuId()`), + /// 所以调用方必须先把子表每行的主键备齐 —— 本 crate 不生成 id + ///(AR7:纯计算,不引 uuid 库)。备不齐 ⇒ 报 `NO_PRIMARY_KEY`, + /// **绝不写空主键**(空主键 = 多行挤成一行)。 + pub primary_keys: BTreeMap, + /// 当前时间(ISO8601,如 `2026-10-31T12:00:00`)。 + /// + /// 🔴 由调用方传入(内核有 chrono),本 crate 不引时间库(AR7)。 + /// `None` ⇒ **不写时间列**,交给数据库的 DEFAULT —— 这比编一个假时间安全。 + pub now: Option, + /// 主表**关联列**的实际值(列名 → 值)。 + /// + /// ## 🔴 为什么需要它 + /// + /// 子表外键的值 = 主表 `relationField` 指向的那一列的值 + /// (基线平台:`mainMap.get(table.getRelationField())`)。 + /// 当 `relationField` **就是主键**时,值 = 主键,调用方可以不登记; + /// 当它指向别的列(如业务编码 `F_Code`)时, + /// 那个值只能从数据库里查出来 ⇒ 由调用方(执行层)查完登记进来。 + /// + /// 本 crate 是**纯计算**层(AR7)⇒ 它不查库,只消费这里登记的值。 + pub relation_values: BTreeMap, +} + +impl WriteContext { + /// 构造一个带用户 id 的上下文。 + pub fn with_user(user_id: impl Into) -> Self { + Self { + user_id: Some(user_id.into()), + ..Default::default() + } + } + + /// 登记一个主键值。 + /// + /// `key` 的形态见 [`WriteContext::primary_keys`]。 + pub fn set_primary_key(&mut self, key: impl Into, value: impl Into) { + self.primary_keys.insert(key.into(), value.into()); + } + + /// 登记子表某一行的主键。 + pub fn set_sub_row_key( + &mut self, + table: &str, + main_id: &str, + row_index: usize, + value: impl Into, + ) { + self.primary_keys.insert( + format!("{table}#{main_id}#{row_index}"), + value.into(), + ); + } + + /// 登记主表某个关联列的实际值(子表外键要指向它)。 + pub fn set_relation_value(&mut self, column: &str, value: impl Into) { + self.relation_values + .insert(column.to_lowercase(), value.into()); + } + + /// 取主表关联列的值。 + /// + /// ## 🔴 参数是**子表模型**,不是主表模型 + /// + /// `relationField` 定义在**子表**上(`TableModel.relationField`), + /// 它说的是「本子表的外键指向主表的**哪一列**」。 + /// 之前传主表模型 ⇒ 主表的 `relationField` 是空串 ⇒ 永远查不到值。 + /// + /// 查不到 ⇒ `None`(调用方应回落到主键)。 + pub fn relation_value(&self, sub_table: &TableSchema) -> Option { + let rel_col = sub_table.relation_column()?; + self.relation_values.get(&rel_col.to_lowercase()).cloned() + } +} + +/// 一次写入计划:主表 SQL + 子表 SQL(按依赖顺序)。 +#[derive(Debug, Clone, PartialEq)] +pub struct WritePlan { + /// 主表新增。 + pub main: Sql, + /// 子表新增(每条对应一行子表数据)。 + pub subs: Vec, +} + +impl WritePlan { + /// 全部 SQL(主表在前)。 + pub fn all(&self) -> Vec<&Sql> { + let mut v: Vec<&Sql> = vec![&self.main]; + v.extend(self.subs.iter()); + v + } + + /// 一共几条 SQL(诊断 / 日志用)。 + pub fn len(&self) -> usize { + 1 + self.subs.len() + } + + /// 一条都没有(理论不会发生 —— 主表 SQL 恒存在)。 + pub fn is_empty(&self) -> bool { + false + } +} + +/// 一次更新的计划。 +#[derive(Debug, Clone, PartialEq)] +pub struct UpdatePlan { + /// 主表更新。 + pub main: Sql, + /// 子表更新 / 新增 / 删除(差集对账的产物)。 + pub subs: Vec, +} + +impl UpdatePlan { + /// 全部 SQL(主表在前)。 + pub fn all(&self) -> Vec<&Sql> { + let mut v: Vec<&Sql> = vec![&self.main]; + v.extend(self.subs.iter()); + v + } + + /// 一共几条 SQL。 + pub fn len(&self) -> usize { + 1 + self.subs.len() + } + + /// 恒不为空(主表 SQL 恒存在)。 + pub fn is_empty(&self) -> bool { + false + } +} + +/// 子表更新的**差集对账**结果。 +/// +/// ## 🔴 为什么必须做差集,而不是「全量覆盖」 +/// +/// 基线平台 `FlowFormDataUtil.updateTable()` 的语义: +/// +/// | 旧库里的行 | 入参里的行 | 动作 | +/// |---|---|---| +/// | 有 | 有(主键相同) | **UPDATE** | +/// | 无 | 有(主键是新的) | **INSERT** | +/// | 有 | 无(入参没这行) | **DELETE**(逻辑/物理按 `logicalDelete`) | +/// +/// 全量覆盖(先 DELETE 全部再 INSERT 全部)会产生两个后果: +/// 1. 行的主键变了 ⇒ 子表主键是**对外契约**(前端可能存着它),一变就断链; +/// 2. 没在 `logicalDelete` 语义下的「删除」变成了物理删,破坏审计。 +#[derive(Debug, Clone, Default, PartialEq)] +pub struct SubDiff { + /// 要更新的行(入参里主键与旧行相同的)。 + pub updates: Vec, + /// 要新增的行(入参里主键是新的,或没给主键)。 + pub inserts: Vec, + /// 要删除的行主键(旧库里有、入参里没有的)。 + pub deletes: Vec, +} + +impl SubDiff { + /// 差集是否为空(没旧行、没新行 ⇒ 子表不用动)。 + pub fn is_empty(&self) -> bool { + self.updates.is_empty() && self.inserts.is_empty() && self.deletes.is_empty() + } + + /// 一共会产生几条子表 SQL(更新 + 新增 + 删除)。 + pub fn statement_count(&self) -> usize { + self.updates.len() + self.inserts.len() + self.deletes.len() + } +} + +/// 子表更新的**行为开关**(对齐基线平台的 `DataModel` 开关)。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SubUpdateOptions { + /// 只更新,不删除缺失的旧行(基线平台 `dataModel.getOnlyUpdate()`)。 + /// + /// 🔴 这是一个**危险**的开关:入参只给了一部分子表行时, + /// 旧行会被保留 —— 但如果调用方本意是「整表替换」, + /// 就会留下幽灵行。默认 `false`(对齐基线默认行为)。 + pub only_update: bool, + /// 逻辑删除(基线平台 `dataModel.getLogicalDelete()`)。 + /// + /// `true` ⇒ 缺失的旧行**逻辑删除**(置删除标记); + /// `false` ⇒ **物理删除**。 + pub logical_delete: bool, +} + +impl Default for SubUpdateOptions { + fn default() -> Self { + Self { + only_update: false, + logical_delete: false, + } + } +} + +/// 子表更新的**上下文**(差集对账需要的信息)。 +#[derive(Debug, Clone)] +pub struct SubUpdateContext { + /// 旧库里的行主键(按外键查出来的)。 + /// + /// 🔴 本 crate 是纯计算层(AR7)⇒ **查库由调用方做**, + /// 这里只消费结果。空 ⇒ 子表没有旧行(全部视为新增)。 + pub old_row_keys: Vec, + /// 子表外键列(模型 `tableField`)。 + pub foreign_key_column: String, + /// 外键的**值**(主表 `relationField` 指向的那一列的实际值)。 + pub foreign_key_value: String, + /// 子表行主键生成器:入参没给主键时,用它生成一个。 + /// + /// 🔴 Java 侧子表主键是**服务端现生成**的(`RandomUtil.uuId()`), + /// 但本 crate 不引 uuid 库(AR7)⇒ 由调用方注入生成器。 + /// 传 `None` ⇒ 入参没给主键的行**报错**(绝不写空主键)。 + pub row_key_generator: Option String>, + /// 选项(`only_update` / `logical_delete`)。 + pub options: SubUpdateOptions, +} + +impl SubUpdateContext { + /// 构造一个上下文(无主键生成器)。 + pub fn new( + old_row_keys: Vec, + foreign_key_column: impl Into, + foreign_key_value: impl Into, + options: SubUpdateOptions, + ) -> Self { + Self { + old_row_keys, + foreign_key_column: foreign_key_column.into(), + foreign_key_value: foreign_key_value.into(), + row_key_generator: None, + options, + } + } +} + +/// 计算子表的**差集**(对齐基线平台 `updateTable()`)。 +/// +/// ## 语义(逐条对齐 Java) +/// +/// ```java +/// List childIdList = 旧库里的行主键; +/// List formDataIdList = 入参里带了主键的行主键; +/// List deleteList = childIdList 中不在 formDataIdList 的; +/// // 再逐行看:主键在 childIdList 里 ⇒ UPDATE,否则 ⇒ INSERT +/// ``` +/// +/// ⇒ 三种结果: +/// - `updates`:入参行主键在旧库里 ⇒ 更新; +/// - `inserts`:入参行主键不在旧库里(或没给主键)⇒ 新增; +/// - `deletes`:旧库行主键不在入参里 ⇒ 删除。 +/// +/// ## 🔴 大小写与类型 +/// +/// Java 用 `String.valueOf(t).contains(...)` 比较 ⇒ **字符串化后比较**。 +/// 这里沿用:主键统一转字符串再比,避免 `123` vs `"123"` 判成两行。 +pub fn diff_sub_rows( + rows: &[Value], + pk_col: &str, + ctx: &SubUpdateContext, +) -> SubDiff { + let old: Vec = ctx.old_row_keys.iter().map(|s| s.to_string()).collect(); + + let mut diff = SubDiff::default(); + + for (idx, row) in rows.iter().enumerate() { + let given_key = row_key_of(row, pk_col); + match given_key { + Some(k) if old.iter().any(|o| o == &k) => { + // 旧库里有这行 ⇒ 更新 + diff.updates.push(row.clone()); + } + Some(k) => { + // 主键是新的 ⇒ 新增 + let mut r = row.clone(); + set_row_key(&mut r, pk_col, &k); + diff.inserts.push(r); + } + None => { + // 没给主键 ⇒ 新增,且主键由调用方生成(或报错) + let key = match ctx.row_key_generator { + Some(f) => f(idx), + None => { + // 没有生成器 ⇒ 这行没法落库,记下来由上层报错 + // (用空串占位,调用方会因缺主键而拒绝) + String::new() + } + }; + let mut r = row.clone(); + set_row_key(&mut r, pk_col, &key); + diff.inserts.push(r); + } + } + } + + // 旧库有、入参没有 ⇒ 删除(`only_update` 时不删) + if !ctx.options.only_update { + for o in &old { + let still_there = rows.iter().any(|r| { + row_key_of(r, pk_col).is_some_and(|k| k == *o) + }); + if !still_there { + diff.deletes.push(o.clone()); + } + } + } + + diff +} + +/// 取一行里的主键值(字符串化)。 +fn row_key_of(row: &Value, pk_col: &str) -> Option { + let obj = row.as_object()?; + for (k, v) in obj { + if k.eq_ignore_ascii_case(pk_col) { + return match v { + Value::String(s) if !s.is_empty() => Some(s.clone()), + Value::Number(n) => Some(n.to_string()), + Value::Null => None, + _ => None, + }; + } + } + None +} + +/// 往一行里写主键(兼容 `F_Id` / `f_id` 两种键名)。 +fn set_row_key(row: &mut Value, pk_col: &str, key: &str) { + let Some(obj) = row.as_object_mut() else { + return; + }; + // 已有的键(可能是 `F_Id`)直接覆盖 + let existing = obj + .keys() + .find(|k| k.eq_ignore_ascii_case(pk_col)) + .cloned(); + match existing { + Some(k) => { + obj.insert(k, Value::String(key.to_string())); + } + None => { + obj.insert(pk_col.to_string(), Value::String(key.to_string())); + } + } +} + +/// 列白名单:某张表允许写入的列(来自模型定义)。 +#[derive(Debug, Clone)] +struct ColumnGuard { + /// 允许的物理列名(小写)。 + allowed: Vec, + /// 主键列名(模型标了 primaryKey 的那个;**排除租户列**)。 + /// + /// 🔴 排除租户列是 Java 的规则:`getKey()` 过滤掉 + /// `field.toLowerCase().contains("tenantid")` 的字段 —— + /// 官方模型里 `f_tenant_id` 也是 `primaryKey=1`,若不排除会选错主键。 + primary_key: Option, + /// 流程任务 id 列名(模型里字段名含 `flowtaskid` 的那个)。 + flow_task_id: Option, + /// 租户列名(模型里字段名含 `tenantid` 的那个)。 + tenant_id: Option, +} + +impl ColumnGuard { + fn allows(&self, column: &str) -> bool { + self.allowed.iter().any(|c| c == column) + } +} + +/// 构造某张表的列白名单 + 系统列定位。 +fn guard_for(table: &TableSchema) -> Result { + let allowed: Vec = table + .fields + .iter() + .filter_map(|c| c.resolved_column()) + .collect(); + if allowed.is_empty() { + return Err(SqlError::UnknownTable(table.table.clone())); + } + + // 主键:primaryKey=1 且**不是租户列**(Java `getKey()` 的规则) + let primary_key = table + .fields + .iter() + .filter(|c| c.primary_key) + .filter(|c| !c.field.to_lowercase().contains(sys::TENANTID)) + .find_map(|c| c.resolved_column()); + + // 流程任务 id:字段名**包含** flowtaskid(Java `getFlowTaskId()` 的规则) + let flow_task_id = table + .fields + .iter() + .filter(|c| c.field.to_lowercase().contains(sys::FLOWTASKID)) + .find_map(|c| c.resolved_column()); + + // 租户列:字段名包含 tenantid + let tenant_id = table + .fields + .iter() + .filter(|c| c.field.to_lowercase().contains(sys::TENANTID)) + .find_map(|c| c.resolved_column()); + + Ok(ColumnGuard { + allowed, + primary_key, + flow_task_id, + tenant_id, + }) +} + +/// 生成一次**新增**的 SQL 计划。 +/// +/// `payload` 的键是**设计态字段名**(`F_Room`)或**物理列名**(`f_room`)—— +/// 两种都接受,与前端提交时用的 `F_Room` 一致。 +/// +/// `main_id` 由调用方生成(用平台统一的 UUID 生成器),这里不生成。 +pub fn plan_insert( + form: &FormSchema, + model: &ModelSchema, + payload: &Value, + ctx: &WriteContext, + main_id: &str, +) -> Result { + let main_table = model.main_table().ok_or(SqlError::NoMainTable)?; + let main_guard = guard_for(main_table)?; + + // 主键列名:模型标了 primaryKey 就用它,否则 f_id + let pk_col = main_guard + .primary_key + .clone() + .unwrap_or_else(|| sys::F_ID.to_string()); + let pk_val = ctx + .primary_keys + .get(&main_table.table) + .cloned() + .unwrap_or_else(|| main_id.to_string()); + + let mut cols: Vec<(String, Value)> = Vec::new(); + let add = |cols: &mut Vec<(String, Value)>, col: &str, v: Value| { + if cols.iter().any(|(c, _)| c == col) { + return; + } + cols.push((col.to_string(), v)); + }; + + // ① 主键 + add(&mut cols, &pk_col, Value::String(pk_val.clone())); + + // ② 业务字段(按表单定义顺序,列白名单过滤) + for field in form.main_fields() { + let Some(col) = field.column_name() else { continue }; + if !main_guard.allows(&col) { + // 表单引用了模型里没有的列 ⇒ 跳过(form.validate 会报出来) + continue; + } + let raw = lookup(payload, &field.v_model, &col); + let value = match auto_fill(&field.jnpf_key) { + AutoFill::Passthrough => match raw { + Some(v) => normalize_value(v, &col)?, + None => { + // 没给值:必填则报错,否则写 NULL + if field.required { + return Err(SqlError::MissingRequired { + table: main_table.table.clone(), + column: col.clone(), + label: field.label.clone(), + }); + } + Value::Null + } + }, + AutoFill::CurrentUserId => Value::String(ctx.user_id.clone().unwrap_or_default()), + AutoFill::Now => match &ctx.now { + Some(t) => Value::String(t.clone()), + None => Value::Null, + }, + AutoFill::CurrentOrganizeIds => Value::String(json_array(&ctx.organize_ids)), + AutoFill::CurrentPositionIds => Value::String(json_array(&ctx.position_ids)), + // 🔴 新增时「最后修改人/时间」置 null(Java `create()` 两个分支都是 null) + AutoFill::ModifyTime | AutoFill::ModifyUser => Value::Null, + AutoFill::BillNumber => ctx + .bill_numbers + .get(&field.v_model) + .cloned() + .or_else(|| ctx.bill_numbers.get(&col).cloned()) + .unwrap_or(Value::Null), + }; + add(&mut cols, &col, value); + } + + // ③ 系统字段 + // 🔴 列名**全部来自模型**(Java 同款规则),不硬编码 —— + // 实测模型里 `F_CreatorTime` 的列是 `f_creatortime`,硬编码 `f_creator_time` 会炸。 + // + // 流程任务 id:Java `createMast()` 无条件写,值 = 主键(**非流程功能也写**)。 + if let Some(flow_col) = &main_guard.flow_task_id { + add( + &mut cols, + flow_col, + Value::String(pk_val.clone()), + ); + } + + // 租户:Java `addTenantId()` 无条件写。 + if let Some(tenant_col) = &main_guard.tenant_id { + if let Some(tid) = &ctx.tenant_id { + add( + &mut cols, + tenant_col, + Value::String(tid.clone()), + ); + } + } + + // 并发锁:Java 只在 `concurrencyLock` 开启时写 `f_version`。 + if form.concurrency_lock.unwrap_or(false) { + if let Some(ver_col) = find_column(main_table, sys::VERSION) { + add(&mut cols, &ver_col, Value::from(0)); + } + } + + // ④ 渲染 SQL + let main_sql = render_insert( + &main_table.table, + &cols, + SqlKind::InsertMain, + )?; + + // ⑤ 子表 + let mut subs = Vec::new(); + for sub in form.sub_tables() { + let sub_model = resolve_sub_table(model, sub)?; + let sub_guard = guard_for(sub_model)?; + let sub_pk = sub_guard + .primary_key + .clone() + .unwrap_or_else(|| sys::F_ID.to_string()); + + // 子表行数据:payload 里以子表 vModel 或表名为键 + let rows = lookup_sub_rows(payload, &sub.v_model, &sub_model.table); + let Some(rows) = rows else { continue }; + let arr = rows.as_array().ok_or_else(|| SqlError::TypeMismatch { + column: sub.v_model.clone(), + expected: "数组", + })?; + + for (idx, row) in arr.iter().enumerate() { + let mut ccols: Vec<(String, Value)> = Vec::new(); + let cadd = |cols: &mut Vec<(String, Value)>, c: &str, v: Value| { + if cols.iter().any(|(x, _)| x == c) { + return; + } + cols.push((c.to_string(), v)); + }; + + // 子表行主键:入参给了就用;否则由调用方按 `表名#主键#行号` 提供, + // 再兜底用 `表名#主键#行号` 形态查一次 —— 都拿不到就**报错**, + // 绝不写空主键(空主键 = 多行挤成一行)。 + let row_pk = lookup(row, &sub_pk, &sub_pk) + .and_then(|v| v.as_str().map(str::to_string)) + .or_else(|| { + ctx.primary_keys + .get(&format!("{}#{}#{}", sub_model.table, pk_val, idx)) + .cloned() + }) + .or_else(|| { + ctx.primary_keys + .get(&format!("{}#{}", sub_model.table, pk_val)) + .cloned() + }) + .ok_or_else(|| SqlError::NoPrimaryKey(sub_model.table.clone()))?; + cadd(&mut ccols, &sub_pk, Value::String(row_pk)); + + // 子表字段:从子节点的 children 取 + for child in &sub.children { + let Some(col) = child.column_name() else { continue }; + if !sub_guard.allows(&col) { + continue; + } + let raw = lookup(row, &child.v_model, &col); + let value = match auto_fill(&child.jnpf_key) { + AutoFill::Passthrough => match raw { + Some(v) => normalize_value(v, &col)?, + None => { + if child.required { + return Err(SqlError::MissingRequired { + table: sub_model.table.clone(), + column: col.clone(), + label: child.label.clone(), + }); + } + Value::Null + } + }, + AutoFill::CurrentUserId => { + Value::String(ctx.user_id.clone().unwrap_or_default()) + } + AutoFill::Now => match &ctx.now { + Some(t) => Value::String(t.clone()), + None => Value::Null, + }, + AutoFill::CurrentOrganizeIds => { + Value::String(json_array(&ctx.organize_ids)) + } + AutoFill::CurrentPositionIds => { + Value::String(json_array(&ctx.position_ids)) + } + // 🔴 新增时「最后修改人/时间」置 null + AutoFill::ModifyTime | AutoFill::ModifyUser => Value::Null, + AutoFill::BillNumber => ctx + .bill_numbers + .get(&child.v_model) + .cloned() + .unwrap_or(Value::Null), + }; + cadd(&mut ccols, &col, value); + } + + // 🔴 外键:子表指向主表的**关联列**。 + // 列名来自模型的 `tableField`(Java `createMastTable()` 同款)—— + // 实测 `test_details` 的外键列是 `f_receivableid`,**不是** `f_foreign_id`。 + // 值取主表 `relationField` 指向的那一列的值(基线平台同款: + // `dataNewMap.get(tableModel.getRelationField())`), + // 默认回落到主表主键(官方 fixture 的 relationField 就是主键列)。 + // + // 🔴 `relationField` 定义在**子表模型**上 —— 查子表,不是主表。 + if let Some(fk_col) = sub_model.foreign_key_column() { + let fk_value = ctx + .relation_value(sub_model) + .unwrap_or_else(|| pk_val.clone()); + cadd( + &mut ccols, + &fk_col, + Value::String(fk_value), + ); + } + + // 租户(子表也有) + if let Some(tenant_col) = &sub_guard.tenant_id { + if let Some(tid) = &ctx.tenant_id { + cadd( + &mut ccols, + tenant_col, + Value::String(tid.clone()), + ); + } + } + + subs.push(render_insert( + &sub_model.table, + &ccols, + SqlKind::InsertSub, + )?); + } + } + + Ok(WritePlan { main: main_sql, subs }) +} + +/// 生成一次**更新**的 SQL 计划。 +/// +/// 与基线平台的差异(刻意):基线平台更新时把**所有系统字段重置**, +/// 这里只更新「入参明确给了的列」+ 最后修改时间/人 —— 更安全, +/// 且避免覆盖并发修改。 +pub fn plan_update( + form: &FormSchema, + model: &ModelSchema, + payload: &Value, + ctx: &WriteContext, + main_id: &str, +) -> Result { + let main_table = model.main_table().ok_or(SqlError::NoMainTable)?; + let main_guard = guard_for(main_table)?; + let pk_col = main_guard + .primary_key + .clone() + .unwrap_or_else(|| sys::F_ID.to_string()); + let mut cols: Vec<(String, Value)> = Vec::new(); + let add = |cols: &mut Vec<(String, Value)>, c: &str, v: Value| { + if cols.iter().any(|(x, _)| x == c) { + return; + } + cols.push((c.to_string(), v)); + }; + + for field in form.main_fields() { + let Some(col) = field.column_name() else { continue }; + if !main_guard.allows(&col) { + continue; + } + let Some(raw) = lookup(payload, &field.v_model, &col) else { + continue; + }; + // 🔴 被系统覆盖的字段在更新时**直接跳过**,不写回入参值 + if auto_fill(&field.jnpf_key).overrides_input() { + continue; + } + let value = normalize_value(raw, &col)?; + add(&mut cols, &col, value); + } + + // 🔴 最后修改时间/人:列名**从模型推导**,不硬编码。 + // 实测模型里是 `f_lastmodifytime` / `f_lastmodifyuserid`(无下划线)。 + if let Some(t) = &ctx.now { + if let Some(c) = find_column(main_table, sys::LAST_MODIFY_TIME) { + add(&mut cols, &c, Value::String(t.clone())); + } else if let Some(c) = find_column(main_table, "lastmodifytime") { + add(&mut cols, &c, Value::String(t.clone())); + } + } + if let Some(uid) = &ctx.user_id { + if let Some(c) = find_column(main_table, sys::LAST_MODIFY_USER_ID) { + add(&mut cols, &c, Value::String(uid.clone())); + } else if let Some(c) = find_column(main_table, "lastmodifyuserid") { + add(&mut cols, &c, Value::String(uid.clone())); + } + } + + let main = render_update( + &main_table.table, + &cols, + &pk_col, + main_id, + SqlKind::UpdateMain, + )?; + + Ok(UpdatePlan { main, subs: Vec::new() }) +} + +/// 生成一次**更新**的 SQL 计划(**含子表差集对账**)。 +/// +/// 与 [`plan_update`] 的差别:**多了子表**。 +/// - [`plan_update`]:只更新主表(子表完全不动); +/// - [`plan_update_full`]:主表 + 子表的 UPDATE / INSERT / DELETE(差集对账)。 +/// +/// ## 🔴 子表差集必须由调用方提供「旧行主键」 +/// +/// 本 crate 是纯计算层(AR7)⇒ 查不了库。 +/// 调用方(内核执行层)要先按外键查旧行主键,塞进 +/// [`SubUpdateContext::old_row_keys`]。 +/// +/// ## 🔴 与基线平台的差异(刻意) +/// +/// 基线平台更新时把**所有系统字段重置**,这里只更新「入参明确给了的列」 +/// + 最后修改时间/人 —— 更安全,且避免覆盖并发修改。 +/// +/// 另:基线平台 `updateTable()` 查旧行用的是**旧值** `oldForeignValue` +/// (主表改之前的关联列值),这里用**新值** —— 因为更新场景下 +/// 关联列一般就是主键,不受影响;若关联列真的变了, +/// 那是「把子表搬到另一个父行」的语义,基线平台也不支持。 +pub fn plan_update_full( + form: &FormSchema, + model: &ModelSchema, + payload: &Value, + ctx: &WriteContext, + main_id: &str, + sub_ctxs: &BTreeMap, +) -> Result { + let mut plan = plan_update(form, model, payload, ctx, main_id)?; + let mut subs: Vec = Vec::new(); + + for sub in form.sub_tables() { + let sub_model = resolve_sub_table(model, sub)?; + let sub_guard = guard_for(sub_model)?; + let sub_pk = sub_guard + .primary_key + .clone() + .unwrap_or_else(|| sys::F_ID.to_string()); + + let Some(sub_ctx) = sub_ctxs.get(&sub_model.table) else { + // 没给子表上下文 ⇒ 子表不动(调用方明确表示「这张子表不参与更新」) + continue; + }; + + // 入参里的子表行 + let rows = lookup_sub_rows(payload, &sub.v_model, &sub_model.table); + let arr: Vec = match rows { + Some(v) => v.as_array().cloned().unwrap_or_default(), + None => Vec::new(), + }; + + let diff = diff_sub_rows(&arr, &sub_pk, sub_ctx); + + // ---- 删除缺失的旧行 ---- + if !diff.deletes.is_empty() { + for key in &diff.deletes { + let sql = if sub_ctx.options.logical_delete { + soft_delete_row(sub_model, &sub_pk, key, ctx)? + } else { + render_delete( + &sub_model.table, + &sub_pk, + key, + SqlKind::HardDelete, + )? + }; + subs.push(sql); + } + } + + // ---- 更新已有行 ---- + for row in &diff.updates { + let key = row_key_of(row, &sub_pk).unwrap_or_default(); + let cols = sub_row_columns(sub, sub_model, &sub_guard, row, ctx, true)?; + if cols.is_empty() { + // 没有可写列 ⇒ 这行不用动(Java 那边也是空 UPDATE 跳过) + continue; + } + subs.push(render_update( + &sub_model.table, + &cols, + &sub_pk, + &key, + SqlKind::UpdateSub, + )?); + } + + // ---- 新增行 ---- + for row in diff.inserts.iter() { + let key = row_key_of(row, &sub_pk).unwrap_or_default(); + if key.is_empty() { + return Err(SqlError::NoPrimaryKey(sub_model.table.clone())); + } + let mut cols = sub_row_columns(sub, sub_model, &sub_guard, row, ctx, false)?; + + // 🔴 主键:子表行主键由调用方(内核)生成 —— Java 侧是 `RandomUtil.uuId()`。 + // `diff_sub_rows` 已经把生成的主键写回行对象了 ⇒ 这里取出来写进列。 + if !cols.iter().any(|(c, _)| c.eq_ignore_ascii_case(&sub_pk)) { + cols.insert( + 0, + (sub_pk.clone(), Value::String(key.clone())), + ); + } + + // 🔴 外键:子表指向主表的关联列。 + // Java `updateTable()`:`generalInsertDSL.set(foreignKey).toValue(foreignValue)`。 + if !sub_ctx.foreign_key_column.is_empty() + && !cols + .iter() + .any(|(c, _)| c.eq_ignore_ascii_case(&sub_ctx.foreign_key_column)) + { + cols.push(( + sub_ctx.foreign_key_column.clone(), + Value::String(sub_ctx.foreign_key_value.clone()), + )); + } + + // 🔴 租户:Java `addTenantId()` 对子表也写。 + if let Some(tenant_col) = &sub_guard.tenant_id { + if let Some(tid) = &ctx.tenant_id { + if !cols.iter().any(|(c, _)| c.eq_ignore_ascii_case(tenant_col)) { + cols.push((tenant_col.clone(), Value::String(tid.clone()))); + } + } + } + + subs.push(render_insert( + &sub_model.table, + &cols, + SqlKind::InsertSub, + )?); + } + } + + plan.subs = subs; + Ok(plan) +} + +/// 取子表一行的可写列(列名 + 值)。 +/// +/// `is_update` ⇒ 更新语义(不写外键、不写创建人/创建时间); +/// `false` ⇒ 新增语义。 +/// +/// 🔴 返回**单一** `Vec<(列名, 值)>` —— 不再返回平行的 `params` 数组。 +/// 两个平行数组靠下标对齐,少 push 一次就会「列数 ≠ 参数数」, +/// 而且不会报错,只会把值错位写到别的列上(静默写坏数据)。 +fn sub_row_columns( + sub: &FieldNode, + sub_model: &TableSchema, + sub_guard: &ColumnGuard, + row: &Value, + ctx: &WriteContext, + is_update: bool, +) -> Result, SqlError> { + let mut cols: Vec<(String, Value)> = Vec::new(); + + for child in &sub.children { + let Some(col) = child.column_name() else { continue }; + if !sub_guard.allows(&col) { + continue; + } + let raw = lookup(row, &child.v_model, &col); + let fill = auto_fill(&child.jnpf_key); + + // 🔴 更新语义:Java 在 `isUpdate` 时**跳过**创建人/创建时间/组织/岗位 + // (`updateTable()` 的 `isUpdate && (CURRORGANIZE || CURRPOSITION || + // CREATETIME || CREATEUSER)` 分支)—— 更新时不能改「谁创建的」。 + // 新增语义下反过来:修改人/修改时间在新增时应置空。 + if is_update + && matches!( + fill, + AutoFill::CurrentOrganizeIds | AutoFill::CurrentPositionIds | AutoFill::Now + | AutoFill::CurrentUserId + ) + { + continue; + } + if !is_update && matches!(fill, AutoFill::ModifyTime | AutoFill::ModifyUser) { + // 新增时「最后修改人/时间」置空(Java `create()` 的两个分支都是 null) + cols.push((col, Value::Null)); + continue; + } + if fill.overrides_input() && !is_update { + // 新增:系统字段由后端填 + let value = match fill { + AutoFill::CurrentUserId => Value::String(ctx.user_id.clone().unwrap_or_default()), + AutoFill::Now => match &ctx.now { + Some(t) => Value::String(t.clone()), + None => Value::Null, + }, + AutoFill::CurrentOrganizeIds => Value::String(json_array(&ctx.organize_ids)), + AutoFill::CurrentPositionIds => Value::String(json_array(&ctx.position_ids)), + AutoFill::BillNumber => ctx + .bill_numbers + .get(&child.v_model) + .cloned() + .or_else(|| ctx.bill_numbers.get(&col).cloned()) + .unwrap_or(Value::Null), + _ => Value::Null, + }; + if !cols.iter().any(|(c, _)| c == &col) { + cols.push((col, value)); + } + continue; + } + if fill.overrides_input() && is_update { + // 🔴 更新:最后修改时间/人由后端填,其余系统字段跳过。 + // Java `update()`:`MODIFYTIME` 写当前时间、`MODIFYUSER` 写当前用户 id。 + // (之前两者都归到 `Null`,更新时被整段跳过 ⇒ 审计链断掉。) + let value = match fill { + AutoFill::ModifyTime => match &ctx.now { + Some(t) => Value::String(t.clone()), + None => Value::Null, + }, + AutoFill::ModifyUser => match &ctx.user_id { + Some(u) => Value::String(u.clone()), + None => Value::Null, + }, + _ => continue, + }; + if !cols.iter().any(|(c, _)| c == &col) { + cols.push((col, value)); + } + continue; + } + + let value = match raw { + Some(v) => normalize_value(v, &col)?, + None => { + if child.required { + return Err(SqlError::MissingRequired { + table: sub_model.table.clone(), + column: col.clone(), + label: child.label.clone(), + }); + } + continue; + } + }; + if !cols.iter().any(|(c, _)| c == &col) { + cols.push((col, value)); + } + } + + Ok(cols) +} + +/// 逻辑删除子表的一行(置删除标记)。 +/// +/// 🔴 表里没有删除标记列 ⇒ **报错**(`LogicalDeleteUnsupported`), +/// 不退化成物理删 —— 动态建表时主表与子表的删除列同进同退, +/// 子表缺删除列说明表建错了,静默物理删会毁掉审计链。 +fn soft_delete_row( + sub_model: &TableSchema, + pk_col: &str, + pk_value: &str, + ctx: &WriteContext, +) -> Result { + let mut cols: Vec<(String, Value)> = Vec::new(); + + let mark_col = find_column(sub_model, sys::DELETE_MARK).ok_or_else(|| { + SqlError::LogicalDeleteUnsupported(sub_model.table.clone()) + })?; + // 🔴 写 **1**,不是 `true`。 + // 官方真实 DDL:`f_delete_mark INTEGER`;Java `TableFeildsEnum.DELETEMARK` + // 的 dataType 也是 `"int"`;基线平台 `FlowFormDataUtil` 写的是 `equalTo(1)`。 + // 写 boolean ⇒ 执行层转成字符串 `"true"` ⇒ PG 报 + // `invalid input syntax for type integer: "true"`。 + cols.push((mark_col, Value::from(1))); + if let Some(t) = &ctx.now { + if let Some(c) = find_column(sub_model, sys::DELETE_TIME) { + cols.push((c, Value::String(t.clone()))); + } + } + if let Some(uid) = &ctx.user_id { + if let Some(c) = find_column(sub_model, sys::DELETE_USER_ID) { + cols.push((c, Value::String(uid.clone()))); + } + } + + render_update( + &sub_model.table, + &cols, + pk_col, + pk_value, + SqlKind::SoftDelete, + ) +} + +/// 生成**逻辑删除**的 SQL。 +/// +/// 对齐基线平台:只置逻辑删除标记 + 删除时间/人,**不物理删除**。 +/// +/// ## 🔴 逻辑删除的列**只在表里有这些列时**才写 —— +/// 实测 `test_receivable` 的 `logicalDelete = false`,表里根本没有删除标记列。 +/// +/// ## 🔴 一列都没有 ⇒ **报错**,不生成空 UPDATE +/// +/// 动态建表时删除列是跟着 `logicalDelete` 一起加的(主表 + 子表同进同退)。 +/// ⇒ 表里没有删除列 = 「这张表不支持逻辑删除」。 +/// 生成空 UPDATE 等于「什么都没删,但返回成功」—— 用户以为删了,实际行还在。 +pub fn plan_soft_delete( + model: &ModelSchema, + ctx: &WriteContext, + main_id: &str, +) -> Result { + let main_table = model.main_table().ok_or(SqlError::NoMainTable)?; + let guard = guard_for(main_table)?; + let pk_col = guard + .primary_key + .clone() + .unwrap_or_else(|| sys::F_ID.to_string()); + + // 🔴 逻辑删除标记列必须有 —— 没有就是「这张表不支持逻辑删除」。 + let mark_col = find_column(main_table, sys::DELETE_MARK).ok_or_else(|| { + SqlError::LogicalDeleteUnsupported(main_table.table.clone()) + })?; + + let mut cols: Vec<(String, Value)> = Vec::new(); + + // 🔴 写 **1**,不是 `true`。 + // 官方真实 DDL:`f_delete_mark INTEGER`;Java `TableFeildsEnum.DELETEMARK` + // 的 dataType 也是 `"int"`;基线平台 `FlowFormDataUtil` 写的是 `equalTo(1)`。 + // 写 boolean ⇒ 执行层转成字符串 `"true"` ⇒ PG 报 + // `invalid input syntax for type integer: "true"`。 + cols.push((mark_col, Value::from(1))); + if let Some(t) = &ctx.now { + if let Some(c) = find_column(main_table, sys::DELETE_TIME) { + cols.push((c, Value::String(t.clone()))); + } + } + if let Some(uid) = &ctx.user_id { + if let Some(c) = find_column(main_table, sys::DELETE_USER_ID) { + cols.push((c, Value::String(uid.clone()))); + } + } + if let Some(t) = &ctx.now { + if let Some(c) = find_column(main_table, sys::LAST_MODIFY_TIME) { + cols.push((c, Value::String(t.clone()))); + } else if let Some(c) = find_column(main_table, "lastmodifytime") { + cols.push((c, Value::String(t.clone()))); + } + } + + Ok(render_update( + &main_table.table, + &cols, + &pk_col, + main_id, + SqlKind::SoftDelete, + )?) +} + +/// 生成**物理删除**的 SQL。 +/// +/// ## 🔴 为什么需要这条路径 +/// +/// 基线平台 `FlowFormDataUtil.deleteTable()`: +/// ```java +/// if (logicalDelete) { UPDATE ... SET delete_mark = 1 ... } +/// else { DELETE FROM ... WHERE pk = ?; } +/// ``` +/// +/// ⇒ `logicalDelete = false` 的表**必须物理 DELETE**。 +/// 退化成「空 UPDATE」会留下一行永远还在的数据(列表里还查得到), +/// 比删不掉更糟 —— 用户以为删了,实际没删。 +pub fn plan_hard_delete( + model: &ModelSchema, + main_id: &str, +) -> Result { + let main_table = model.main_table().ok_or(SqlError::NoMainTable)?; + let guard = guard_for(main_table)?; + let pk_col = guard + .primary_key + .clone() + .unwrap_or_else(|| sys::F_ID.to_string()); + render_delete(&main_table.table, &pk_col, main_id, SqlKind::HardDelete) +} + +/// 一次删除的计划(主表 + 子表)。 +#[derive(Debug, Clone, PartialEq)] +pub struct DeletePlan { + /// 主表删除语句(逻辑或物理)。 + pub main: Sql, + /// 子表删除语句(按外键批量删)。 + pub subs: Vec, +} + +impl DeletePlan { + /// 全部 SQL(主表在前 —— 顺序与基线平台相反,见下)。 + /// + /// 🔴 **顺序**:基线平台是「先删主表、再删子表」; + /// 这里**必须反过来**(先子表后主表),否则主表删完、 + /// 子表那批 `DELETE ... WHERE fk = ?` 仍能执行(FK 约束在 PG 里默认不级联、 + /// 且我们不建 FK 约束),但如果将来建了 FK 约束就会**违反外键约束**。 + /// 先删子表 ⇒ 主表还在时子表已清空 ⇒ 任何时刻都不违反约束。 + pub fn all(&self) -> Vec<&Sql> { + let mut v: Vec<&Sql> = self.subs.iter().collect(); + v.push(&self.main); + v + } + + /// 一共几条 SQL。 + pub fn len(&self) -> usize { + 1 + self.subs.len() + } + + /// 恒不为空(主表 SQL 恒存在)。 + pub fn is_empty(&self) -> bool { + false + } +} + +/// 生成一次**删除**的完整计划(主表 + 子表级联)。 +/// +/// ## 🔴 语义严格对齐 `FlowFormDataUtil.deleteTable()` +/// +/// 1. `logicalDelete = true` ⇒ 主表置删除标记,子表也置删除标记; +/// 2. `logicalDelete = false` ⇒ 主表**物理 DELETE**,子表**物理 DELETE**; +/// 3. 子表删除条件用**外键列 = 主表关联列的值**, +/// 不是「子表主键 = 主表主键」—— 外键列来自模型 `tableField`, +/// 关联值来自模型 `relationField` 指向的主表列。 +/// +/// ## 🔴 子表外键的值从哪来 +/// +/// 基线平台:`Object relationFieldValue = mainMap.get(table.getRelationField());` +/// —— 读的是**主表那一行的实际值**,不是主键。 +/// 例:主表 `relationField = F_Code`(业务编码), +/// 子表 `tableField = F_Code_Ref` ⇒ 子表外键值 = 主表的业务编码。 +/// 这与「子表外键 = 主表主键」不是一回事 —— 官方 fixture 里两者恰好都指向 `f_id`, +/// 但那是巧合,不能当规则。 +pub fn plan_delete( + form: &FormSchema, + model: &ModelSchema, + ctx: &WriteContext, + main_id: &str, +) -> Result { + let logical = form.logical_delete.unwrap_or(false); + // 主表必须存在(没有主表谈不上删除一条记录)。 + model.main_table().ok_or(SqlError::NoMainTable)?; + + // 🔴 子表外键的值**按子表各算**(`relationField` 定义在子表模型上)—— + // 不同子表可能指向不同的主表列,不能在主表层面统一取。 + + // ---- 子表:按外键批量删 ---- + let mut subs = Vec::new(); + for sub in form.sub_tables() { + let Some(sub_model) = resolve_sub_table(model, sub).ok() else { + continue; + }; + let Some(fk_col) = sub_model.foreign_key_column() else { + // 基线平台:`foreignField == null` ⇒ 抛 SQL 异常(不是跳过)。 + return Err(SqlError::UnknownColumn { + table: sub_model.table.clone(), + column: "tableField".to_string(), + }); + }; + // 🔴 子表没有删除标记列时,逻辑删除会退化成物理删 —— + // 先确认这张表真的在模型里(guard_for 会校验列白名单非空)。 + let _sub_guard = guard_for(sub_model)?; + + // 🔴 外键的值:子表 `relationField` 指向的主表列的实际值。 + // `relationField` 定义在**子表模型**上(基线平台: + // `mainMap.get(table.getRelationField())` —— `table` 是子表的 TableModel)。 + // 若它指向的不是主键 ⇒ 值只能由调用方查库后登记进 `ctx.relation_values`; + // 拿不到就**报错**,绝不猜(猜错 = 删错行的子表数据)。 + let relation_value = ctx + .relation_value(sub_model) + .unwrap_or_else(|| main_id.to_string()); + + let sql = if logical { + // 逻辑删除:置删除标记。 + // 🔴 子表没有删除标记列 ⇒ **报错**,不静默物理删 + // (动态建表时主表与子表的删除列同进同退)。 + let mark_col = find_column(sub_model, sys::DELETE_MARK).ok_or_else(|| { + SqlError::LogicalDeleteUnsupported(sub_model.table.clone()) + })?; + let mut cols: Vec<(String, Value)> = Vec::new(); + // 🔴 写 **1**,不是 `true`(`f_delete_mark` 是 INTEGER —— 见上)。 + cols.push((mark_col, Value::from(1))); + if let Some(t) = &ctx.now { + if let Some(c) = find_column(sub_model, sys::DELETE_TIME) { + cols.push((c, Value::String(t.clone()))); + } + } + if let Some(uid) = &ctx.user_id { + if let Some(c) = find_column(sub_model, sys::DELETE_USER_ID) { + cols.push((c, Value::String(uid.clone()))); + } + } + render_update( + &sub_model.table, + &cols, + &fk_col, + &relation_value, + SqlKind::SoftDelete, + )? + } else { + // 物理删除:按**外键列**删(不是按子表主键) + render_delete_by_column( + &sub_model.table, + &fk_col, + &relation_value, + SqlKind::HardDelete, + )? + }; + subs.push(sql); + } + + // ---- 主表 ---- + let main = if logical { + plan_soft_delete(model, ctx, main_id)? + } else { + plan_hard_delete(model, main_id)? + }; + + Ok(DeletePlan { main, subs }) +} + +/// 渲染「按任意列删」(`DELETE FROM t WHERE = $1`)。 +fn render_delete_by_column( + table: &str, + col: &str, + value: &str, + kind: SqlKind, +) -> Result { + check_identifier("表名", table)?; + check_identifier("列名", col)?; + Ok(Sql { + text: format!("DELETE FROM {} WHERE {} = $1", table, col), + params: vec![Value::String(value.to_string())], + param_columns: vec![col.to_string()], + table: table.to_string(), + kind, + }) +} + +/// 在表定义里按**列名特征**找一个列(大小写不敏感,`contains`)。 +/// +/// 这是「系统列名从模型推导」的核心工具:只认**特征**,不认具体名字 —— +/// `f_creatortime` 与 `f_creator_time` 都含 `creatortime`/`creator_time`, +/// 具体用哪个由模型说了算。 +fn find_column(table: &TableSchema, feature: &str) -> Option { + table + .fields + .iter() + .filter_map(|c| c.resolved_column()) + .find(|c| c.to_lowercase().contains(&feature.to_lowercase())) +} + +/// 🔴 找出子表节点对应的**物理表**。 +/// +/// ## 为什么不能「取第一个非主表」 +/// +/// 官方数据里一张功能可能带**多个子表**。按顺序取第一个 ⇒ +/// 第二个子表的数据会被写进第一个子表的表里 —— 静默串表,最难查。 +/// +/// ## 解析顺序(从强到弱) +/// 1. `__config__.relationTable`(子表字段的 `relationTable` 明确指向子表)—— 最可信 +/// 2. 子表节点的 `__config__.tableName` +/// 3. 都没有 ⇒ 只有一个子表时用它;有多个 ⇒ **报错**(不猜) +fn resolve_sub_table<'a>( + model: &'a ModelSchema, + sub: &FieldNode, +) -> Result<&'a TableSchema, SqlError> { + // ① 子表节点的 tableName + if let Some(name) = sub.table_name.as_deref() { + if let Some(t) = model.table(name) { + return Ok(t); + } + } + // ② 子表字段的 relationTable(子节点的 __config__ 里) + for child in &sub.children { + if let Some(rt) = child.relation_table.as_deref() { + if let Some(t) = model.table(rt) { + return Ok(t); + } + } + } + // ③ 兜底:只有一个子表就用它 + let subs = model.sub_tables(); + match subs.len() { + 0 => Err(SqlError::UnknownTable(sub.v_model.clone())), + 1 => Ok(subs[0]), + _ => Err(SqlError::UnknownTable(sub.v_model.clone())), + } +} + +/// 渲染 INSERT。 +/// +/// 🔴 **列与值必须同源** —— 这里只收 `cols: &[(String, Value)]`, +/// 参数由函数自己从 `cols` 生成。 +/// 之前是「`cols` 数组 + 平行的 `params` 数组」两个独立入参, +/// 靠下标对齐 —— 少 push 一次就会**列数 ≠ 参数数**, +/// 而且不报错,只是把值错位写到别的列上(静默写坏数据)。 +/// 从类型上收口,两个数组就不可能不一致。 +fn render_insert( + table: &str, + cols: &[(String, Value)], + kind: SqlKind, +) -> Result { + check_identifier("表名", table)?; + for (c, _) in cols { + check_identifier("列名", c)?; + } + let names: Vec<&str> = cols.iter().map(|(c, _)| c.as_str()).collect(); + let marks: Vec = (1..=cols.len()).map(|i| format!("${i}")).collect(); + let text = format!( + "INSERT INTO {} ({}) VALUES ({})", + table, + names.join(", "), + marks.join(", ") + ); + Ok(Sql { + text, + params: cols.iter().map(|(_, v)| v.clone()).collect(), + param_columns: cols.iter().map(|(c, _)| c.clone()).collect(), + table: table.to_string(), + kind, + }) +} + +/// 渲染 UPDATE。 +/// +/// 🔴 **必须有 WHERE** —— 没有 WHERE 的 UPDATE 会把整张表改成同一个值。 +/// 这是本模块最危险的一处,故由 `render_update` 统一收口,不给调用方绕过的机会。 +/// +/// 🔴 **主键只出现在 WHERE,不出现在 SET** —— 写主键等于「改主键」, +/// 而主键是对外契约(子表外键指向它)⇒ 改了就产生孤儿行。 +/// +/// 🔴 **列与值同源** —— 同 [`render_insert`]:只收 `cols`, +/// 参数自己生成,杜绝「列数 ≠ 参数数」把值错位写到别的列。 +fn render_update( + table: &str, + cols: &[(String, Value)], + pk_col: &str, + pk_value: &str, + kind: SqlKind, +) -> Result { + check_identifier("表名", table)?; + check_identifier("列名", pk_col)?; + for (c, _) in cols { + check_identifier("列名", c)?; + } + if pk_value.is_empty() { + return Err(SqlError::NoPrimaryKey(table.to_string())); + } + // 🔴 主键不能被写进 SET(哪怕值相同,改主键 = 改对外契约) + let mut all_params: Vec = Vec::new(); + let mut param_columns: Vec = Vec::new(); + let mut sets: Vec = Vec::new(); + for (c, v) in cols { + if c.eq_ignore_ascii_case(pk_col) { + continue; + } + sets.push(format!("{c} = ${}", all_params.len() + 1)); + all_params.push(v.clone()); + param_columns.push(c.clone()); + } + if sets.is_empty() { + return Err(SqlError::NoColumnsToUpdate(table.to_string())); + } + let pk_index = all_params.len() + 1; + all_params.push(Value::String(pk_value.to_string())); + // WHERE 里的主键占位符也带上列名 —— 执行层要按它 cast(主键常是 uuid 文本) + param_columns.push(pk_col.to_string()); + let text = format!( + "UPDATE {} SET {} WHERE {} = ${}", + table, + sets.join(", "), + pk_col, + pk_index + ); + Ok(Sql { + text, + params: all_params, + param_columns, + table: table.to_string(), + kind, + }) +} + +/// 渲染 DELETE。 +/// +/// 🔴 **必须有 WHERE** —— 没有 WHERE 的 DELETE 会清空整张表。 +fn render_delete( + table: &str, + pk_col: &str, + pk_value: &str, + kind: SqlKind, +) -> Result { + check_identifier("表名", table)?; + check_identifier("列名", pk_col)?; + if pk_value.is_empty() { + return Err(SqlError::NoPrimaryKey(table.to_string())); + } + Ok(Sql { + text: format!("DELETE FROM {} WHERE {} = $1", table, pk_col), + params: vec![Value::String(pk_value.to_string())], + param_columns: vec![pk_col.to_string()], + table: table.to_string(), + kind, + }) +} + +/// 标识符合法性检查(只允许字母/数字/下划线,且不以数字开头)。 +/// +/// 🔴 表名与列名来自**用户可编辑的 JSON**(`f_tables_data`), +/// 即使过了「在模型里」的白名单,也要再过一道字符检查 —— +/// 防止模型定义里被人塞了 `"t; DROP TABLE x"`。 +/// +/// ## 🔴 为什么是 `pub` +/// +/// 执行层(内核)也要**动态拼查询 SQL**(查子表旧行、查主表关联列)—— +/// 那里的表名列名同样来自模型定义,同样必须过这道检查。 +/// 规则只有一份(在这里),两边复用 ⇒ 不会出现「生成层拦了、执行层没拦」的漏洞。 +pub fn check_identifier(kind: &'static str, value: &str) -> Result<(), SqlError> { + let ok = !value.is_empty() + && value + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '_') + && !value.starts_with(|c: char| c.is_ascii_digit()); + if ok { + Ok(()) + } else { + Err(SqlError::IllegalIdentifier { + kind, + value: value.to_string(), + }) + } +} + +/// 在 payload 里找值:先按设计态字段名,再按物理列名(大小写不敏感)。 +/// +/// 🔴 **pub 是有意的**:内核侧的唯一性 / 业务主键校验必须用**同一份**取值规则 +/// —— 若校验层另写一份「按列名找值」,就会与 SQL 生成层对同一个字段 +/// 得出不同结论(一个认为给了值、另一个认为没给)⇒ 校验通过但写进去是 NULL。 +pub fn lookup(payload: &Value, v_model: &str, column: &str) -> Option { + let obj = payload.as_object()?; + if let Some(v) = obj.get(v_model) { + return Some(v.clone()); + } + for (k, v) in obj { + if k.eq_ignore_ascii_case(v_model) || k.eq_ignore_ascii_case(column) { + return Some(v.clone()); + } + } + None +} + +/// 在 payload 里找子表行数组。 +fn lookup_sub_rows(payload: &Value, v_model: &str, table: &str) -> Option { + let obj = payload.as_object()?; + if let Some(v) = obj.get(v_model) { + return Some(v.clone()); + } + for (k, v) in obj { + if k.eq_ignore_ascii_case(v_model) || k.eq_ignore_ascii_case(table) { + return Some(v.clone()); + } + } + None +} + +/// 值归一化:空串 → NULL、空数组 → NULL、列表 → JSON 字符串。 +/// +/// 对齐基线平台的 `getInsertDSL()` + `valueToNull()`: +/// - `data == null || StringUtils.isEmpty(data.toString())` → `toNull()` +/// - 空 List → null +/// - 非空 List → `JsonUtil.getObjectToString(data)`(JSON 字符串) +fn normalize_value(v: Value, column: &str) -> Result { + match v { + Value::Null => Ok(Value::Null), + Value::String(s) => { + if s.is_empty() { + Ok(Value::Null) + } else { + Ok(Value::String(s)) + } + } + Value::Array(a) => { + if a.is_empty() { + Ok(Value::Null) + } else { + // 🔴 数组一律序列化成 JSON 字符串(前端多选/子表就是这么存的) + Ok(Value::String( + serde_json::to_string(&Value::Array(a)).unwrap_or_default(), + )) + } + } + Value::Object(_) => Err(SqlError::UnsupportedValue { + column: column.to_string(), + }), + other => Ok(other), + } +} + +/// id 列表 → JSON 数组字符串。 +fn json_array(ids: &[String]) -> String { + serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::form::FormSchema; + use crate::model::ModelSchema; + + /// 最小表单:一个 billRule + 一个必填 input。 + const FORM: &str = r#"{ + "formRef": "formRef", "formModel": "formData", + "fields": [ + { "__vModel__": "F_Code", "__config__": { "jnpfKey": "billRule", "label": "单号", "layout": "colFormItem", "tableName": "biz_main" } }, + { "__vModel__": "F_Room", "__config__": { "jnpfKey": "input", "label": "房间", "layout": "colFormItem", "tableName": "biz_main", "required": true } } + ] + }"#; + + /// 最小模型:一张主表。 + /// + /// 🔴 列名**刻意模仿官方数据的真实形态**: + /// - `F_Id` → `f_id`(主键) + /// - `F_CreatorTime` → `f_creatortime`(**没有下划线** —— 官方就是这样) + /// - `f_tenant_id` → 租户列(**也是 primaryKey=1** ⇒ 不能选成主键) + const MODEL: &str = r#"[ + { "table": "biz_main", "tableName": "主表", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "F_Code", "columnName": null, "dataType": "varchar" }, + { "field": "F_Room", "columnName": null, "dataType": "varchar" }, + { "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" }, + { "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 } + ]} + ]"#; + + fn form() -> FormSchema { + FormSchema::from_str(FORM).expect("表单应可解析") + } + + fn model() -> ModelSchema { + ModelSchema::from_str(MODEL).expect("模型应可解析") + } + + /// 🔴 带「最后修改时间/人」列的模型(列名形态照官方:`f_lastmodifytime`)。 + const MODEL_WITH_MODIFY: &str = r#"[ + { "table": "biz_main", "tableName": "主表", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "F_Room", "columnName": null, "dataType": "varchar" }, + { "field": "F_LastModifyTime", "columnName": null, "dataType": "datetime" }, + { "field": "F_LastModifyUserId", "columnName": null, "dataType": "varchar" }, + { "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 } + ]} + ]"#; + + fn model_with_modify() -> ModelSchema { + ModelSchema::from_str(MODEL_WITH_MODIFY).expect("模型应可解析") + } + + 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 + } + + /// 从 INSERT 语句里取出列清单(按顺序)。 + fn insert_columns(sql: &Sql) -> Vec { + sql.text + .split_once(" (") + .expect("INSERT 应有列清单") + .1 + .split_once(") VALUES") + .expect("INSERT 应有 VALUES") + .0 + .split(", ") + .map(|s| s.to_string()) + .collect() + } + + /// 🔴 UPDATE 必须带 WHERE —— 没有 WHERE 的 UPDATE 会改全表。 + #[test] + fn update_always_has_where_clause() { + let plan = plan_update( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "main-1", + ) + .expect("应能生成更新计划"); + assert!( + plan.main.text.contains("WHERE f_id = $"), + "UPDATE 缺 WHERE 子句: {}", + plan.main.text + ); + assert!(!plan.main.text.contains("A-101"), "值被拼进 SQL 文本了"); + } + + /// 🔴 空主键必须报错 —— 否则会退化成 UPDATE 全表。 + #[test] + fn update_rejects_empty_primary_key() { + let err = plan_update( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "", + ) + .expect_err("空主键必须被拒"); + assert_eq!(err.code(), "NO_PRIMARY_KEY"); + } + + /// INSERT 的值必须全部走占位符。 + #[test] + fn insert_uses_placeholders_only() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "main-1", + ) + .expect("应能生成新增计划"); + assert!(plan.main.text.contains("VALUES ($1"), "应有占位符: {}", plan.main.text); + assert!(!plan.main.text.contains("A-101")); + assert_eq!(plan.main.params.len(), plan.main.text.matches('$').count()); + } + + /// 🔴 必填字段没给值 ⇒ 报错(而不是写 NULL)。 + #[test] + fn missing_required_field_is_rejected() { + let err = plan_insert( + &form(), + &model(), + &serde_json::json!({}), + &ctx(), + "main-1", + ) + .expect_err("必填缺失必须被拒"); + assert_eq!(err.code(), "MISSING_REQUIRED"); + } + + /// 🔴 系统生成字段不被入参覆盖。 + #[test] + fn system_generated_field_ignores_payload() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101", "F_Code": "用户伪造的单号" }), + &ctx(), + "main-1", + ) + .expect("应能生成新增计划"); + assert!( + !plan + .main + .params + .iter() + .any(|p| p.as_str() == Some("用户伪造的单号")), + "入参覆盖了系统生成的单号: {:?}", + plan.main.params + ); + } + + /// 🔴 主键**不能**选成租户列(官方模型里 `f_tenant_id` 也是 primaryKey=1)。 + #[test] + fn tenant_column_is_never_used_as_primary_key() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "main-1", + ) + .unwrap(); + let cols = insert_columns(&plan.main); + // 主键列应是 f_id(第一个) + assert_eq!(cols[0], "f_id", "主键选错了: {cols:?}"); + // 租户列单独写,且值是租户 id + let tenant_idx = cols + .iter() + .position(|c| c == "f_tenant_id") + .expect("应有租户列"); + assert_eq!(plan.main.params[tenant_idx], Value::String("0".into())); + } + + /// 🔴 反自证:系统列名**不能硬编码**。 + /// + /// 官方模型里 `F_CreatorTime` 的列是 `f_creatortime`(无下划线)。 + /// 若代码里写死 `f_creator_time`,真实库上直接 `column does not exist`。 + /// + /// 断言方式:带 `createTime` 控件的表单,生成出来的列必须是**模型里的**那个。 + #[test] + fn system_columns_come_from_model_not_hardcoded() { + let f = FormSchema::from_str( + r#"{"fields":[ + {"__vModel__":"F_CreatorTime","__config__":{"jnpfKey":"createTime","label":"创建时间","tableName":"biz_main"}} + ]}"#, + ) + .unwrap(); + let plan = plan_insert(&f, &model(), &serde_json::json!({}), &ctx(), "main-1").unwrap(); + let cols = insert_columns(&plan.main); + assert!( + cols.iter().any(|c| c == "f_creatortime"), + "应使用模型推导出的列名: {cols:?}" + ); + assert!( + !cols.iter().any(|c| c == "f_creator_time"), + "出现了硬编码的 f_creator_time —— 真实库上会 column does not exist: {cols:?}" + ); + } + + /// 🔴 表里没有的列**不许**出现在 INSERT 里(否则真实库报 column does not exist)。 + #[test] + fn no_column_outside_model_is_emitted() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "main-1", + ) + .unwrap(); + let cols = insert_columns(&plan.main); + let allowed = model().main_table().unwrap().column_names(); + for c in &cols { + assert!( + allowed.contains(c), + "列 {c} 不在模型里: {cols:?}" + ); + } + } + + /// 🔴 标识符注入:模型里塞了带分号的表名必须被拒。 + #[test] + fn identifier_injection_is_rejected() { + let evil = ModelSchema::from_str( + r#"[{ "table": "biz_main; DROP TABLE users", "tableName": "坏表", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": "f_id", "primaryKey": true } + ]}]"#, + ) + .unwrap(); + let err = plan_insert(&form(), &evil, &serde_json::json!({}), &ctx(), "m1") + .expect_err("非法标识符必须被拒"); + assert_eq!(err.code(), "ILLEGAL_IDENTIFIER"); + } + + /// 列白名单:表单引用了模型里没有的列 ⇒ 跳过而不是报错。 + #[test] + fn column_not_in_model_is_skipped() { + let f = FormSchema::from_str( + r#"{"fields":[ + {"__vModel__":"F_Ghost","__config__":{"jnpfKey":"input","label":"幽灵列","tableName":"biz_main"}} + ]}"#, + ) + .unwrap(); + let plan = plan_insert(&f, &model(), &serde_json::json!({ "F_Ghost": "x" }), &ctx(), "m1") + .expect("应能生成计划"); + let cols = insert_columns(&plan.main); + assert!( + !cols.iter().any(|c| c == "f_ghost"), + "模型里没有的列不应出现在 INSERT 里: {cols:?}" + ); + } + + /// 空模型 ⇒ 解析失败。 + #[test] + fn empty_model_array_fails_to_parse() { + assert!(ModelSchema::from_str("[]").is_err()); + } + + /// 逻辑删除:**表里没有删除列 ⇒ 报错**(不是生成空 UPDATE)。 + /// + /// 🔴 生成空 UPDATE = 「什么都没删但返回成功」—— 用户以为删了,实际行还在。 + #[test] + fn soft_delete_rejects_table_without_delete_columns() { + let err = plan_soft_delete(&model(), &ctx(), "main-1") + .expect_err("没有删除列的表不支持逻辑删除"); + assert_eq!(err.code(), "LOGICAL_DELETE_UNSUPPORTED"); + } + + /// 逻辑删除:表里**有**删除列时,正常生成带 WHERE 的 UPDATE。 + #[test] + fn soft_delete_writes_delete_columns_when_present() { + let model = ModelSchema::from_str( + r#"[{ "table": "biz_main", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": "f_id", "primaryKey": 1 }, + { "field": "f_delete_mark", "columnName": "f_delete_mark", "dataType": "int" }, + { "field": "f_delete_time", "columnName": "f_delete_time", "dataType": "timestamp" } + ]}]"#, + ) + .unwrap(); + let sql = plan_soft_delete(&model, &ctx(), "main-1").expect("应能生成"); + assert!( + sql.text.contains("WHERE f_id = $"), + "逻辑删除必须带 WHERE: {}", + sql.text + ); + assert!( + sql.text.contains("f_delete_mark"), + "应写删除标记: {}", + sql.text + ); + assert_eq!(sql.kind, SqlKind::SoftDelete); + } + + /// 空串 → NULL(对齐基线 `valueToNull()`)。 + #[test] + fn empty_string_becomes_null() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "" }), + &ctx(), + "m1", + ) + .unwrap(); + let cols = insert_columns(&plan.main); + let idx = cols.iter().position(|c| c == "f_room").expect("应有 f_room"); + assert!( + plan.main.params[idx].is_null(), + "空串应归一化成 NULL,实际: {:?}", + plan.main.params[idx] + ); + } + + /// 空数组 → NULL(前端多选清空时的常见形态)。 + #[test] + fn empty_array_becomes_null() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": [] }), + &ctx(), + "m1", + ) + .unwrap(); + let cols = insert_columns(&plan.main); + let idx = cols.iter().position(|c| c == "f_room").expect("应有 f_room"); + assert!( + plan.main.params[idx].is_null(), + "空数组应归一化成 NULL,实际: {:?}", + plan.main.params[idx] + ); + } + + /// 非空数组 → JSON 字符串(前端多选就是这么存的)。 + #[test] + fn non_empty_array_becomes_json_string() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": ["A", "B"] }), + &ctx(), + "m1", + ) + .unwrap(); + let cols = insert_columns(&plan.main); + let idx = cols.iter().position(|c| c == "f_room").expect("应有 f_room"); + assert_eq!( + plan.main.params[idx], + Value::String(r#"["A","B"]"#.into()), + "非空数组应序列化成 JSON 字符串" + ); + } + + /// 🔴 反自证:如果 WHERE 被谁删掉,这把尺子必须变红。 + #[test] + fn every_update_like_sql_has_where() { + let model = ModelSchema::from_str( + r#"[{ "table": "biz_main", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": "f_id", "primaryKey": 1 }, + { "field": "F_Room", "columnName": "f_room" }, + { "field": "f_delete_mark", "columnName": "f_delete_mark" } + ]}]"#, + ) + .unwrap(); + let ups = [ + plan_update(&form(), &model, &serde_json::json!({ "F_Room": "x" }), &ctx(), "m1") + .unwrap() + .main, + plan_soft_delete(&model, &ctx(), "m1").unwrap(), + ]; + for s in ups { + assert!( + s.text.contains(" WHERE "), + "{} 缺 WHERE —— 会改全表: {}", + s.kind.as_str(), + s.text + ); + } + } + + // --------------------------------------------------------------- + // 子表差集对账(对齐 Java `FlowFormDataUtil.updateTable()`) + // --------------------------------------------------------------- + + /// 差集上下文(旧行主键 = `old-1` / `old-2`)。 + fn sub_ctx(old_keys: &[&str], logical: bool) -> SubUpdateContext { + SubUpdateContext::new( + old_keys.iter().map(|s| s.to_string()).collect(), + "f_main_id", + "main-1", + SubUpdateOptions { + only_update: false, + logical_delete: logical, + }, + ) + } + + /// 🔴 三种归属必须分清:更新 / 新增 / 删除。 + /// + /// 对齐 Java: + /// ```java + /// deleteList = childIdList 中不在 formDataIdList 的; + /// 主键在 childIdList 里 ⇒ UPDATE,否则 ⇒ INSERT + /// ``` + #[test] + fn diff_classifies_update_insert_and_delete() { + let rows = serde_json::json!([ + { "F_Id": "old-1", "F_Item": "A" }, // 旧库有 ⇒ 更新 + { "F_Id": "new-9", "F_Item": "B" } // 旧库没有 ⇒ 新增 + ]); + let diff = diff_sub_rows(rows.as_array().unwrap(), "f_id", &sub_ctx(&["old-1", "old-2"], false)); + + assert_eq!(diff.updates.len(), 1, "old-1 应是更新: {diff:?}"); + assert_eq!(diff.inserts.len(), 1, "new-9 应是新增: {diff:?}"); + assert_eq!(diff.deletes, vec!["old-2".to_string()], "old-2 应被删: {diff:?}"); + } + + /// 🔴 入参里没给主键的行 ⇒ 新增,且主键由生成器补。 + #[test] + fn diff_assigns_generated_key_to_new_rows() { + let rows = serde_json::json!([{ "F_Item": "A" }]); + let mut c = sub_ctx(&[], false); + c.row_key_generator = Some(|i| format!("gen-{i}")); + let diff = diff_sub_rows(rows.as_array().unwrap(), "f_id", &c); + assert_eq!(diff.inserts.len(), 1); + assert_eq!(row_key_of(&diff.inserts[0], "f_id").as_deref(), Some("gen-0")); + } + + /// 🔴 没有生成器且入参没给主键 ⇒ 主键为空 ⇒ 上层必须拒绝(不写空主键)。 + #[test] + fn diff_without_generator_leaves_key_empty() { + let rows = serde_json::json!([{ "F_Item": "A" }]); + let diff = diff_sub_rows(rows.as_array().unwrap(), "f_id", &sub_ctx(&[], false)); + assert_eq!(diff.inserts.len(), 1); + // 空主键 ⇒ `row_key_of` 视为「没有主键」⇒ 上层 `plan_update_full` 会报 + // `NoPrimaryKey`,绝不写空主键(空主键 = 多行挤成一行)。 + assert!( + row_key_of(&diff.inserts[0], "f_id").is_none(), + "空主键必须被视作缺失: {diff:?}" + ); + } + + /// `only_update = true` ⇒ 缺失的旧行**不删**。 + #[test] + fn only_update_keeps_missing_rows() { + let rows = serde_json::json!([{ "F_Id": "old-1" }]); + let mut c = sub_ctx(&["old-1", "old-2"], false); + c.options.only_update = true; + let diff = diff_sub_rows(rows.as_array().unwrap(), "f_id", &c); + assert!(diff.deletes.is_empty(), "only_update 不该删行: {diff:?}"); + assert_eq!(diff.updates.len(), 1); + } + + /// 🔴 主键比较必须**字符串化**(Java `String.valueOf(t)`)。 + #[test] + fn diff_compares_keys_as_strings() { + let rows = serde_json::json!([{ "F_Id": 123 }]); + let diff = diff_sub_rows(rows.as_array().unwrap(), "f_id", &sub_ctx(&["123"], false)); + assert_eq!(diff.updates.len(), 1, "数字主键应与字符串主键视为同一行: {diff:?}"); + assert!(diff.inserts.is_empty()); + assert!(diff.deletes.is_empty()); + } + + // --------------------------------------------------------------- + // 参数 ↔ 列映射(执行层靠它决定 cast) + // --------------------------------------------------------------- + + /// 🔴 `param_columns` 必须与 `params` 一一对应,且列名是真的。 + /// + /// 之前执行层是「按模型字段顺序猜占位符对应哪一列」—— + /// 而**写入列顺序 ≠ 模型字段顺序**(系统列是运行时追加的)⇒ 猜错就写脏数据。 + #[test] + fn param_columns_line_up_with_params() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + assert_eq!( + plan.main.param_columns.len(), + plan.main.params.len(), + "参数与列映射长度必须一致" + ); + let cols = insert_columns(&plan.main); + assert_eq!(&plan.main.param_columns, &cols, "映射顺序应与 INSERT 列一致"); + assert_eq!(plan.main.column_of(0), Some("f_id")); + } + + /// UPDATE 的 WHERE 主键占位符也要带列名(执行层要按它 cast)。 + #[test] + fn update_param_columns_include_where_key() { + let plan = plan_update( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + let last = plan.main.param_columns.len() - 1; + assert_eq!( + plan.main.column_of(last), + Some("f_id"), + "最后一个参数是 WHERE 里的主键: {:?}", + plan.main.param_columns + ); + assert_eq!(plan.main.params.len(), plan.main.param_columns.len()); + } + + /// 🔴 主键**不能出现在 SET** 里(改主键 = 改对外契约)。 + #[test] + fn primary_key_is_never_in_set_clause() { + let plan = plan_update( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + let set_part = plan + .main + .text + .split_once(" SET ") + .unwrap() + .1 + .split_once(" WHERE ") + .unwrap() + .0; + assert!( + !set_part.contains("f_id"), + "SET 里不该有主键: {set_part}" + ); + } + + // ============================================================ + // 🔴 回归测试:列与值必须同源(修「列数 ≠ 参数数」) + // ============================================================ + + /// 🔴 **每一条**生成的 SQL,占位符个数必须等于列数。 + /// + /// 之前 `render_insert` 收的是「`cols` 数组 + 平行的 `params` 数组」, + /// 两个数组靠下标对齐 —— 少 push 一次参数就**不报错**, + /// 只是把值错位写到别的列上(静默写坏数据)。 + /// + /// 现在的防线是**类型**:`render_insert` 只收 `cols`, + /// 参数自己生成 ⇒ 两个数组不可能不一致。 + /// 这条测试是那道防线的守门人。 + #[test] + fn every_statement_has_one_placeholder_per_column() { + let plan = plan_insert( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + + for sql in plan.all() { + let marks = sql.text.matches("$").count(); + assert_eq!( + marks, + sql.params.len(), + "🔴 {} 的占位符数与参数数不一致 ⇒ 值会错位写进别的列: {}", + sql.kind.as_str(), + sql.text + ); + assert_eq!( + sql.param_columns.len(), + sql.params.len(), + "🔴 {} 的参数↔列映射长度不一致: {}", + sql.kind.as_str(), + sql.text + ); + } + } + + /// 🔴 UPDATE 的 SET 列数必须等于「参数数 - 1」(最后一个是 WHERE 的主键)。 + #[test] + fn update_placeholder_count_matches_set_columns() { + let plan = plan_update( + &form(), + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + let set_part = plan.main.text.split_once(" SET ").unwrap().1; + let set_part = set_part.split_once(" WHERE ").unwrap().0; + let set_cols = set_part.split(", ").count(); + assert_eq!( + set_cols + 1, + plan.main.params.len(), + "🔴 SET 列数({set_cols}) 与参数数({}) 不匹配: {}", + plan.main.params.len(), + plan.main.text + ); + } + + // ============================================================ + // 🔴 回归测试:modifyTime / modifyUser 的更新语义 + // ============================================================ + + /// 带 modifyTime / modifyUser 控件的表单(合成,但语义照 Java)。 + const FORM_WITH_MODIFY: &str = r#"{ + "formRef": "formRef", "formModel": "formData", + "fields": [ + { "__vModel__": "F_Room", "__config__": { "jnpfKey": "input", "label": "房间", "layout": "colFormItem", "tableName": "biz_main" } }, + { "__vModel__": "F_LastModifyTime", "__config__": { "jnpfKey": "modifyTime", "label": "修改时间", "layout": "colFormItem", "tableName": "biz_main" } }, + { "__vModel__": "F_LastModifyUserId", "__config__": { "jnpfKey": "modifyUser", "label": "修改人", "layout": "colFormItem", "tableName": "biz_main" } } + ] + }"#; + + /// 🔴 **更新**时最后修改时间/人**必须被写**。 + /// + /// Java `update()`: + /// ```java + /// case MODIFYTIME: if (!childNeedAdd) { value = new Date(); } break; + /// case MODIFYUSER: if (!childNeedAdd) { value = user.getUserId(); } break; + /// ``` + /// + /// 之前两者都归到 `AutoFill::Null` ⇒ 更新时被整段跳过 ⇒ + /// 「最后修改人/时间」永远停在旧值 —— 审计链断掉。 + #[test] + fn update_writes_modify_time_and_modify_user() { + let form = FormSchema::from_str(FORM_WITH_MODIFY).expect("表单应可解析"); + let plan = plan_update( + &form, + &model_with_modify(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + + let cols = &plan.main.param_columns; + assert!( + cols.iter().any(|c| c == "f_lastmodifytime"), + "🔴 更新时没写最后修改时间: {cols:?}" + ); + assert!( + cols.iter().any(|c| c == "f_lastmodifyuserid"), + "🔴 更新时没写最后修改人: {cols:?}" + ); + // 值也要对:时间 = ctx.now,人 = ctx.user_id + let time_idx = cols.iter().position(|c| c == "f_lastmodifytime").unwrap(); + let user_idx = cols.iter().position(|c| c == "f_lastmodifyuserid").unwrap(); + assert_eq!( + plan.main.params[time_idx], + Value::String("2026-10-31T12:00:00".to_string()), + "最后修改时间应写当前时间" + ); + assert_eq!( + plan.main.params[user_idx], + Value::String("u-1".to_string()), + "最后修改人应写当前用户 id" + ); + } + + /// 🔴 **新增**时最后修改时间/人**必须置 null**(Java `create()` 两个分支都是 null)。 + /// + /// 「刚建就显示被人改过」是脏审计。 + #[test] + fn insert_nulls_modify_time_and_modify_user() { + let form = FormSchema::from_str(FORM_WITH_MODIFY).expect("表单应可解析"); + let plan = plan_insert( + &form, + &model_with_modify(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + + let cols = &plan.main.param_columns; + for c in ["f_lastmodifytime", "f_lastmodifyuserid"] { + let idx = cols.iter().position(|x| x == c); + assert!(idx.is_some(), "新增时应该写 {c}(置 null): {cols:?}"); + assert_eq!( + plan.main.params[idx.unwrap()], + Value::Null, + "🔴 新增时 {c} 应为 null" + ); + } + } + + /// 🔴 反自证:**列不在模型里 ⇒ 不能写**(列白名单先于自动填充生效)。 + /// + /// 这条测试的意义:如果哪天有人把列白名单去掉, + /// 上面两条会「因为列写不进去而假通过」—— + /// 这条保证白名单真的在拦。 + #[test] + fn modify_columns_are_skipped_when_not_in_model() { + let form = FormSchema::from_str(FORM_WITH_MODIFY).expect("表单应可解析"); + // MODEL 里没有 F_LastModifyTime / F_LastModifyUserId + let plan = plan_insert( + &form, + &model(), + &serde_json::json!({ "F_Room": "A-101" }), + &ctx(), + "m1", + ) + .unwrap(); + assert!( + !plan + .main + .param_columns + .iter() + .any(|c| c == "f_lastmodifytime"), + "🔴 模型里没有的列不该被写: {:?}", + plan.main.param_columns + ); + } +} diff --git a/crates/sspf-lowcode/src/widget.rs b/crates/sspf-lowcode/src/widget.rs index c7f5a0f..5a8bb22 100644 --- a/crates/sspf-lowcode/src/widget.rs +++ b/crates/sspf-lowcode/src/widget.rs @@ -107,6 +107,27 @@ impl WidgetKind { /// /// 不是「保持入参」:新增的行还没被改过,「最后修改人」为空才是正确的。 /// 如果照抄入参,会出现「刚建就显示被别人改过」的脏审计。 +/// +/// ## 🔴 为什么 `ModifyTime` 与 `ModifyUser` 必须拆成两个变体 +/// +/// 基线平台 `FlowFormDataUtil` 里这是**两个不同的 switch 分支**: +/// +/// ```java +/// // create() —— 新增:两者都置 null +/// case JnpfKeyConsts.MODIFYTIME: value = null; break; +/// case JnpfKeyConsts.MODIFYUSER: value = null; break; +/// +/// // update() —— 更新:modifyTime 写当前时间,modifyUser 写当前用户 id +/// case JnpfKeyConsts.MODIFYTIME: +/// if (!childNeedAdd) { value = new Date(); } +/// break; +/// case JnpfKeyConsts.MODIFYUSER: +/// if (!childNeedAdd) { value = user.getUserId(); } +/// break; +/// ``` +/// +/// 之前把两者合并成一个 `Null` ⇒ **更新时两者都没写**, +/// 「最后修改人 / 最后修改时间」永远停在旧值 —— 审计链断掉。 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum AutoFill { /// 用入参原值(普通业务字段)。 @@ -119,8 +140,10 @@ pub enum AutoFill { CurrentOrganizeIds, /// 当前用户的岗位 id 列表,序列化成 JSON 字符串(`currPosition`)。 CurrentPositionIds, - /// 新增时置 `null`(`modifyTime` / `modifyUser`)。 - Null, + /// 最后修改时间:新增置 `null`,更新写当前时间(`modifyTime`)。 + ModifyTime, + /// 最后修改人:新增置 `null`,更新写当前用户 id(`modifyUser`)。 + ModifyUser, /// 单据号生成器产出(`billRule`,`ruleType=1` 时)。 BillNumber, } @@ -134,7 +157,8 @@ impl AutoFill { AutoFill::Now => "now", AutoFill::CurrentOrganizeIds => "currentOrganizeIds", AutoFill::CurrentPositionIds => "currentPositionIds", - AutoFill::Null => "null", + AutoFill::ModifyTime => "modifyTime", + AutoFill::ModifyUser => "modifyUser", AutoFill::BillNumber => "billNumber", } } @@ -145,18 +169,20 @@ impl AutoFill { } } -/// 控件 → 新增时的自动填充行为。 +/// 控件 → 自动填充行为。 /// -/// 对齐 `FlowFormDataUtil.create()` 的 switch 分支;未知控件走 `Passthrough`。 +/// 对齐 `FlowFormDataUtil.create()` / `update()` 的 switch 分支;未知控件走 `Passthrough`。 +/// +/// 🔴 `modifyTime` 与 `modifyUser` 在基线平台是**两个独立分支**, +/// 新增时都置 null、更新时分别写「当前时间」和「当前用户 id」⇒ 不能合并。 pub fn auto_fill(jnpf_key: &str) -> AutoFill { match jnpf_key { "createUser" | "createUserId" => AutoFill::CurrentUserId, "createTime" => AutoFill::Now, "currOrganize" | "currDept" => AutoFill::CurrentOrganizeIds, "currPosition" => AutoFill::CurrentPositionIds, - "modifyTime" | "modifyUser" | "lastModifyTime" | "lastModifyUser" | "modifyUserId" => { - AutoFill::Null - } + "modifyTime" | "lastModifyTime" => AutoFill::ModifyTime, + "modifyUser" | "lastModifyUser" | "modifyUserId" => AutoFill::ModifyUser, "billRule" => AutoFill::BillNumber, _ => AutoFill::Passthrough, } @@ -307,13 +333,25 @@ mod tests { assert_eq!(auto_fill("currPosition"), AutoFill::CurrentPositionIds); assert_eq!(auto_fill("billRule"), AutoFill::BillNumber); // 新增时清空 —— 「刚建就显示被人改过」是脏审计 - assert_eq!(auto_fill("modifyTime"), AutoFill::Null); - assert_eq!(auto_fill("modifyUser"), AutoFill::Null); + assert_eq!(auto_fill("modifyTime"), AutoFill::ModifyTime); + assert_eq!(auto_fill("modifyUser"), AutoFill::ModifyUser); // 普通字段不动 assert_eq!(auto_fill("input"), AutoFill::Passthrough); assert_eq!(auto_fill("calculate"), AutoFill::Passthrough); } + /// 🔴 `modifyTime` 与 `modifyUser` 必须是**两个不同的分支**。 + /// + /// 基线平台 `update()`:`MODIFYTIME` 写当前时间、`MODIFYUSER` 写当前用户 id。 + /// 合并成一个变体 ⇒ 更新时两者都没写 ⇒ 「最后修改人/时间」永远停在旧值。 + #[test] + fn modify_time_and_modify_user_are_distinct() { + assert_ne!(auto_fill("modifyTime"), auto_fill("modifyUser")); + assert_eq!(auto_fill("lastModifyTime"), AutoFill::ModifyTime); + assert_eq!(auto_fill("lastModifyUser"), AutoFill::ModifyUser); + assert_eq!(auto_fill("modifyUserId"), AutoFill::ModifyUser); + } + /// 凡是被覆盖的,`accepts_input` 必须是 false —— 否则「传了也没用」但没人告知。 #[test] fn overridden_fields_do_not_accept_input() { diff --git a/crates/sspf-lowcode/tests/real_ddl.rs b/crates/sspf-lowcode/tests/real_ddl.rs new file mode 100644 index 0000000..09a4ead --- /dev/null +++ b/crates/sspf-lowcode/tests/real_ddl.rs @@ -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())); + } + } +} diff --git a/crates/sspf-lowcode/tests/real_sql.rs b/crates/sspf-lowcode/tests/real_sql.rs new file mode 100644 index 0000000..f8df0bf --- /dev/null +++ b/crates/sspf-lowcode/tests/real_sql.rs @@ -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 { + 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} 不该在这个功能的模型里" + ); +} diff --git a/crates/sspf-mcp/src/tools/lowcode.rs b/crates/sspf-mcp/src/tools/lowcode.rs new file mode 100644 index 0000000..0a6c96f --- /dev/null +++ b/crates/sspf-mcp/src/tools/lowcode.rs @@ -0,0 +1,352 @@ +//! lowcode —— 低代码**动态 CRUD** 的写工具(P2-b)。 +//! +//! ## 这三个工具是干什么的 +//! +//! 低代码功能(`base_visual_dev` 里那条记录)自己带一套表结构定义 +//! (`f_tables_data`)与控件树(`f_form_data`)。 +//! 这三个工具让 AI **按设计稿直接读写业务数据**, +//! 不必为每个低代码功能手写一套 Rust handler。 +//! +//! | 工具 | 动作 | 对齐的基线平台方法 | +//! |---|---|---| +//! | `data.record.insert` | 新增一条(含子表) | `FlowFormDataUtil.create()` | +//! | `data.record.update` | 更新一条(含子表差集对账) | `FlowFormDataUtil.update()` | +//! | `data.record.delete` | 删除一条(逻辑/物理) | `FlowFormDataUtil.deleteTable()` | +//! +//! ## 🔴 三条与「普通写工具」不同的约定 +//! +//! 1. **设计稿 vs 真实库必须一致**:落库前拿 `information_schema` 比一遍列, +//! 对不上就报 `COLUMN_MISMATCH`,**拒绝写**。 +//! (官方数据里 `columnName` 全是 null,列名是从 `field` 推导的 —— +//! 推导必然有偏差,不比对就是让数据库报 `column does not exist`。) +//! 2. **一个事务**:主表失败 ⇒ 子表不能留孤儿行。 +//! 3. **`dry_run`**:先看 SQL 再决定落不落库。写工具默认就该这样。 +//! +//! ## 🔴 参数命名的分层约定(别混) +//! +//! | 层 | 命名 | 例子 | +//! |---|---|---| +//! | **元工具**(`sspf_call` / `sspf_discover`) | snake_case | `dry_run`、`tool_id` | +//! | **业务工具**(本文件这三个) | camelCase | `dryRun`、`recordId`、`enCode` | +//! +//! 业务工具用 camelCase 是**对齐基线平台的前端 API 契约** +//! (`enCode` / `urlAddress` / `fullName` 都是那个形状)—— +//! 这样前端切到 Rust 后端时,一行都不用改。 +//! 元工具是本平台自己定义的协议 ⇒ 用 Rust 侧的 snake_case。 +//! +//! ## 🔴 子表更新是**差集对账**,不是全量覆盖 +//! +//! 入参里有、库里没有 ⇒ 新增;入参里没有、库里有 ⇒ 删除; +//! 两边都有 ⇒ 更新。详见 `sspf_lowcode::diff_sub_rows`。 + +use serde_json::Value; + +use crate::adapter::{BoxFut, PlatformAdapter, ToolError}; +use crate::registry::{Annotations, Category, Example, Hints, Pitfall, Severity, ToolDef}; + +macro_rules! passthrough { + ($name:ident, $op:literal) => { + fn $name<'a>( + adapter: &'a dyn PlatformAdapter, + args: Value, + ) -> BoxFut<'a, Result> { + Box::pin(async move { adapter.invoke($op, args).await }) + } + }; +} + +// ================================================================ data.record.insert + +passthrough!(record_insert_handler, "data.record.insert"); + +pub const DATA_RECORD_INSERT: ToolDef = ToolDef { + id: "data.record.insert", + category: Category::Data, + title: "新增低代码记录", + one_liner: "按低代码设计稿新增一条记录(主表+子表,可 dry_run)", + input_schema: r#"{ + "type": "object", + "properties": { + "id": { "type": "string", "description": "功能 id(查库)" }, + "enCode": { "type": "string", "description": "或功能编码(查库)" }, + "data": { "type": "object", "description": "字段值,键用设计态字段名(如 F_Room);子表用数组" }, + "dryRun": { "type": "boolean", "default": true, "description": "true=只生成 SQL 不落库(默认建议先演练)" } + }, + "required": ["data"], + "additionalProperties": false + }"#, + annotations: Annotations::CREATE, + hints: Hints { + when_to_use: &[ + "给低代码功能造测试数据", + "把一份结构化数据灌进低代码功能", + "AI 要复现线上问题时先演练再落库", + ], + when_not_to_use: &[ + "表还没建出来(先 schema.table.create)", + "只是要读数据(用 data.query)", + "改已有记录(用 data.record.update)", + ], + preconditions: &[ + "该功能的 f_form_data 与 f_tables_data 都存在", + "低代码表必须**先建表**再存数据(表不存在会报 TABLE_NOT_IN_DB)", + "子表的每一行都要有主键 —— 平台侧服务端自动生成,不用自己给", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "直接给真实值落库,不先 dryRun", + right: "先 dryRun=true 看生成的 SQL 与参数,再 dryRun=false 落库", + rationale: "写工具的第一原则是**先看再写**。低代码的列名是从设计稿推导的,\ + 推导与真实库可能有偏差;dryRun 阶段就会报 COLUMN_MISMATCH。", + }, + Pitfall { + severity: Severity::P0, + wrong: "给单号字段(billRule)传自己的值", + right: "单号由后端生成,别传;传了也会被忽略", + rationale: "单号是业务编号规则的一部分,后端生成才唯一。\ + 入参覆盖单号会破坏编号序列,且前端看到的值与规则算出的对不上。", + }, + Pitfall { + severity: Severity::P0, + wrong: "以为重复数据能塞进去", + right: "设计稿标了「唯一 / 业务主键」的字段,重复会被拒(UNIQUE_CONSTRAINT_VIOLATED / BUSINESS_KEY_VIOLATED)", + rationale: "基线平台在落库前有这两道校验:普通输入框标 `unique` ⇒ 全表唯一;\ + 启用 `useBusinessKey` ⇒ 业务主键字段的**组合**唯一。\ + 查重只算**未删除**的行(逻辑删除的行不占位)。", + }, + Pitfall { + severity: Severity::P1, + wrong: "把子表行写成空数组或干脆不给", + right: "不给子表键 = 这张子表不参与写入;给空数组 = 明确表示没有行", + rationale: "两种语义不同:更新时「不给」保留旧行,「空数组」清空旧行(差集对账)。", + }, + ], + examples: &[ + Example { + args: r#"{"enCode":"receivableDemo","data":{"F_Room":"A-101","F_Company_name":"某某公司"},"dryRun":true}"#, + note: "先演练", + }, + Example { + args: r#"{"enCode":"receivableDemo","data":{"F_Room":"A-101"},"dryRun":false}"#, + note: "确认无误后落库", + }, + ], + }, + handler: record_insert_handler, +}; + +// ================================================================ data.record.update + +passthrough!(record_update_handler, "data.record.update"); + +pub const DATA_RECORD_UPDATE: ToolDef = ToolDef { + id: "data.record.update", + category: Category::Data, + title: "更新低代码记录", + one_liner: "按低代码设计稿更新一条记录(子表走差集对账)", + input_schema: r#"{ + "type": "object", + "properties": { + "id": { "type": "string", "description": "功能 id(查库)" }, + "enCode": { "type": "string", "description": "或功能编码(查库)" }, + "recordId": { "type": "string", "description": "要更新的记录主键" }, + "data": { "type": "object", "description": "要改的字段值;**只写要改的字段**,没写的字段不动" }, + "dryRun": { "type": "boolean", "default": true, "description": "true=只生成 SQL 不落库" } + }, + "required": ["recordId", "data"], + "additionalProperties": false + }"#, + annotations: Annotations::CREATE, + hints: Hints { + when_to_use: &["改低代码功能里某条记录的若干字段", "增删子表行"], + when_not_to_use: &[ + "想改主键(主键是对外契约,改了就断链)", + "记录不存在(先 data.query 查一下)", + ], + preconditions: &[ + "recordId 必须真实存在(来自 data.query 的结果)", + "只写要改的字段 —— 没写的字段不会被清空", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "以为更新是「整条替换」", + right: "只写要改的字段;没写的字段保持原值", + rationale: "更新是**部分更新**(只 SET 入参给了的列 + 最后修改时间/人)。\ + 整条替换会清掉没提到的字段。", + }, + Pitfall { + severity: Severity::P0, + wrong: "给子表传完整行列表就以为「多余的会被删」", + right: "子表确实按差集对账:**入参里没有的旧行会被删**(逻辑删或物理删)", + rationale: "这与主表的「部分更新」语义**不同**。子表是「以入参为准」的全量对账。\ + 只想改一行的某个字段,也要把这张子表的**所有行**都传进来,否则旧的会被删。", + }, + Pitfall { + severity: Severity::P1, + wrong: "在 data 里传主键", + right: "主键只放在 recordId 里", + rationale: "改主键等于改对外契约(子表外键指向它)⇒ 会产生孤儿行。\ + 平台侧会直接忽略 data 里的主键。", + }, + ], + examples: &[ + Example { + args: r#"{"enCode":"receivableDemo","recordId":"查出来的 id","data":{"F_Room":"B-202"},"dryRun":true}"#, + note: "只改一个字段", + }, + ], + }, + handler: record_update_handler, +}; + +// ================================================================ data.record.delete + +passthrough!(record_delete_handler, "data.record.delete"); + +pub const DATA_RECORD_DELETE: ToolDef = ToolDef { + id: "data.record.delete", + category: Category::Data, + title: "删除低代码记录", + one_liner: "删一条低代码记录(逻辑/物理按功能设置),可 dry_run", + input_schema: r#"{ + "type": "object", + "properties": { + "id": { "type": "string", "description": "功能 id(查库)" }, + "enCode": { "type": "string", "description": "或功能编码(查库)" }, + "recordId": { "type": "string", "description": "要删的记录主键" }, + "dryRun": { "type": "boolean", "default": true, "description": "true=只生成 SQL 不落库" } + }, + "required": ["recordId"], + "additionalProperties": false + }"#, + annotations: Annotations::DESTRUCTIVE, + hints: Hints { + when_to_use: &["删掉造错的测试数据", "下线一条不该存在的记录"], + when_not_to_use: &[ + "只是想让它「看不见」(那是逻辑删除,前提是功能开了 logicalDelete)", + "不确定记录 id(先 data.query 确认,别乱猜)", + ], + preconditions: &[ + "recordId 必须真实存在", + "🔴 物理删除不可恢复 —— 先 dryRun=true 看清楚要删什么", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "以为删除永远是逻辑删除", + right: "看功能里的 logicalDelete:false = **物理 DELETE**,行真没了", + rationale: "基线平台的 `deleteTable()` 就是这么分的:logicalDelete=false 时\ + 走 `DELETE FROM`,走的是物理删除 ⇒ 不可恢复、且破坏审计。", + }, + Pitfall { + severity: Severity::P0, + wrong: "以为删主表就完事了", + right: "子表会跟着删(按外键批量删/逻辑删)", + rationale: "子表数据挂在主表外键上;不删会变成孤儿行,\ + 而且下次同主键重建时会把旧数据带出来。", + }, + Pitfall { + severity: Severity::P1, + wrong: "在功能开了 logicalDelete 但表里没有删除列时硬删", + right: "会报 LOGICAL_DELETE_UNSUPPORTED —— 这是**表建错了**,要先修表", + rationale: "动态建表时删除列是跟着 logicalDelete 一起加的(主表子表同进同退)。\ + 表里没有删除列 = 这个功能从来没建对过。", + }, + ], + examples: &[ + Example { + args: r#"{"enCode":"receivableDemo","recordId":"查出来的 id","dryRun":true}"#, + note: "先看要删什么", + }, + ], + }, + handler: record_delete_handler, +}; + +/// P2-b 的低代码写工具(3 个)。 +pub static LOWCODE_TOOLS: &[ToolDef] = &[ + DATA_RECORD_INSERT, + DATA_RECORD_UPDATE, + DATA_RECORD_DELETE, +]; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn lowcode_tools_are_well_formed() { + assert_eq!(LOWCODE_TOOLS.len(), 3); + for t in LOWCODE_TOOLS { + let s = t.schema_value(); + assert!(s.get("x-schema-error").is_none(), "{} schema 非法", t.id); + assert!( + t.one_liner.chars().count() <= 40, + "{} one_liner 超 40 字", + t.id + ); + assert!(!t.hints.when_to_use.is_empty(), "{} 缺 when_to_use", t.id); + assert!(!t.hints.when_not_to_use.is_empty(), "{} 缺 when_not_to_use", t.id); + assert!(!t.hints.preconditions.is_empty(), "{} 缺 preconditions", t.id); + assert!(!t.hints.examples.is_empty(), "{} 缺 examples", t.id); + for p in t.hints.pitfalls { + assert!(!p.rationale.trim().is_empty(), "{} 的坑缺 rationale", t.id); + } + } + } + + /// 🔴 写工具不能标只读;删除必须标 destructive。 + #[test] + fn lowcode_write_tools_are_annotated() { + for t in LOWCODE_TOOLS { + assert!(!t.annotations.read_only, "{} 是写工具", t.id); + } + let del = LOWCODE_TOOLS + .iter() + .find(|t| t.id == "data.record.delete") + .unwrap(); + assert!(del.annotations.destructive, "delete 必须标 destructive"); + } + + /// 🔴 三个工具都必须支持 dryRun —— 写工具默认先看再写。 + #[test] + fn every_write_tool_supports_dry_run() { + for t in LOWCODE_TOOLS { + let s = t.schema_value(); + assert!( + s["properties"]["dryRun"].is_object(), + "{} 必须有 dryRun 参数", + t.id + ); + } + } + + /// 🔴 **schema 里不许出现「声明了但没实现」的参数**。 + /// + /// 这不是洁癖 —— 是**行为契约**:AI 看到 `idempotent` 就会以为 + /// 「传了它,重复调用不会重复建记录」。 + /// 但基线平台根本没有这个语义(查过 Java 源码:无 idempotent / 幂等), + /// 防重复靠的是「单行唯一」+「业务主键」两道校验(已实现)。 + /// ⇒ 留着一个不生效的开关 = 骗 AI。 + /// + /// 白名单里的参数都是**真能在内核里找到对应实现**的。 + #[test] + fn schema_declares_only_implemented_parameters() { + const ALLOWED: &[&str] = &["id", "enCode", "data", "recordId", "dryRun"]; + for t in LOWCODE_TOOLS { + let s = t.schema_value(); + let props = s["properties"].as_object().expect("properties 应是对象"); + for key in props.keys() { + assert!( + ALLOWED.contains(&key.as_str()), + "{} 声明了未实现的参数「{}」—— \ + 要么实现它,要么从 schema 里删掉(别让 AI 以为它生效)", + t.id, + key + ); + } + } + } +} diff --git a/crates/sspf-mcp/src/tools/mod.rs b/crates/sspf-mcp/src/tools/mod.rs index 8ab4930..76a7aa6 100644 --- a/crates/sspf-mcp/src/tools/mod.rs +++ b/crates/sspf-mcp/src/tools/mod.rs @@ -20,6 +20,7 @@ pub mod business; pub mod form; +pub mod lowcode; pub mod meta; pub mod permission; pub mod write; @@ -214,6 +215,10 @@ pub static ALL_TOOLS: &[ToolDef] = &[ form::FORM_LIST, form::FORM_DESCRIBE, form::FORM_VALIDATE, + // —— 第六批(P2-b):低代码动态 CRUD(写,带 dry_run)—— + lowcode::DATA_RECORD_INSERT, + lowcode::DATA_RECORD_UPDATE, + lowcode::DATA_RECORD_DELETE, ]; #[cfg(test)] diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index a16cc1e..fa66117 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -179,6 +179,32 @@ impl Db { self.pg.shutdown().await } + /// 开一个**真事务**(`BEGIN` … `COMMIT` / `ROLLBACK`)。 + /// + /// ## 🔴 为什么必须显式事务 + /// + /// pglite 的 `exec`(simple protocol)整批是**一个隐式事务**, + /// 但 `exec_params`(extended protocol)**只能单语句**。 + /// 动态 CRUD 写一条记录要写「主表 + N 张子表」⇒ 必须显式事务, + /// 否则主表成功、子表失败 ⇒ 库里留下**孤儿行**(子表外键指向不存在的主表)。 + /// + /// ## 🔴 锁语义 + /// + /// 本层的 `Db.lock`(tokio Mutex)在事务期间**一直被持有** ⇒ + /// 事务期间其它 `Db` 调用全部排队,不会与事务交错; + /// pglite 自己的 `tx_lock` 是第二道保险。 + /// + /// ⚠️ **事务内不许调 `db.*`** —— 那会等同一把 `Db.lock`,直接死锁。 + /// 事务内的一切查询都要走 [`DbTransaction`] 自己的方法。 + pub async fn begin(&self) -> Result, pglite::Error> { + let guard = self.lock.lock().await; + let tx = self.pg.transaction().await?; + Ok(DbTransaction { + tx, + _guard: guard, + }) + } + // ---- 以下为**持锁调用**的内部实现(调用方已持有 `self.lock`)---- async fn query_json_inner( @@ -238,6 +264,84 @@ impl Db { } } +/// 一个**显式事务**(`BEGIN` … `COMMIT` / `ROLLBACK`)。 +/// +/// ## 🔴 三条使用纪律 +/// +/// 1. **事务内不许调 `Db::*`** —— `Db.lock` 已被本事务持有(tokio Mutex 不可重入) +/// ⇒ 那样写会直接死锁。事务内的查询一律走本类型的方法。 +/// 2. **必须显式 `commit` / `rollback`** —— 不提交就 `Drop` ⇒ pglite 自动回滚 +/// (`Transaction::drop` 里会 `rollback_fire_and_forget`), +/// 表现是「代码看着执行完了,库里什么都没有」,最难查。 +/// 3. **`commit` / `rollback` 消耗 `self`** —— 这是 Rust 的所有权在替你防「提交两次」。 +pub struct DbTransaction<'a> { + /// pglite 的事务句柄。 + tx: pglite::Transaction<'a>, + /// 本层的进程级业务锁(S3)—— 事务期间一直持有 ⇒ 其它 DB 调用全部排队。 + /// + /// 🔴 **为什么不能丢**:pglite 自己的 `tx_lock` 只保证「一次 SQL 调用」不交错, + /// 而本层需要的是「一次业务操作(多条 SQL)」整体串行。 + _guard: tokio::sync::MutexGuard<'a, ()>, +} + +impl<'a> DbTransaction<'a> { + /// 执行一条带参数语句(**单语句**,extended protocol)。 + pub async fn exec_params( + &self, + sql: &str, + params: &[&(dyn ToSql + Sync)], + ) -> Result<(), pglite::Error> { + self.tx.query(sql, params).await.map(|_| ()) + } + + /// 执行一条无参数语句(simple protocol,可多语句)。 + pub async fn exec(&self, sql: &str) -> Result<(), pglite::Error> { + self.tx.exec(sql).await + } + + /// 查询(带参数)⇒ 行数组。 + pub async fn query( + &self, + sql: &str, + params: &[&(dyn ToSql + Sync)], + ) -> Result, pglite::Error> { + self.tx.query(sql, params).await + } + + /// 查询 ⇒ JSON 数组(与 [`Db::query_json`] 同款归一逻辑)。 + pub async fn query_json( + &self, + sql: &str, + params: &[&(dyn ToSql + Sync)], + ) -> Result, pglite::Error> { + let inner = trim_sql(sql); + let alias_info = collect_alias_info(inner); + let wrapped = format!("SELECT row_to_json(q)::text AS _row FROM ({inner}) AS q"); + let rows = self.tx.query(&wrapped, params).await?; + let mut out = Vec::with_capacity(rows.len()); + for row in rows { + let Some(text) = row.get::>(0)? else { + continue; + }; + let value = serde_json::from_str::(&text).map_err(|e| { + pglite::Error::Protocol(format!("row_to_json 结果反序列化失败: {e}")) + })?; + out.push(normalize_json_keys(value, &alias_info)); + } + Ok(out) + } + + /// 提交。 + pub async fn commit(self) -> Result<(), pglite::Error> { + self.tx.commit().await + } + + /// 回滚。 + pub async fn rollback(self) -> Result<(), pglite::Error> { + self.tx.rollback().await + } +} + /// 去掉首尾空白与**结尾**的分号(调用方的 SQL 常带 `;`;包成子查询时不能留)。 fn trim_sql(sql: &str) -> &str { sql.trim().trim_end_matches(';').trim_end() diff --git a/src/backend/src/lib.rs b/src/backend/src/lib.rs index 80da6aa..c02650f 100644 --- a/src/backend/src/lib.rs +++ b/src/backend/src/lib.rs @@ -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; diff --git a/src/backend/src/lowcode_check.rs b/src/backend/src/lowcode_check.rs new file mode 100644 index 0000000..fcb24db --- /dev/null +++ b/src/backend/src/lowcode_check.rs @@ -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 = 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 = Vec::new(); + let mut values: Vec> = 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 = Vec::new(); + let mut params: Vec = 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 { + // 先按 `__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 { + table + .primary_keys() + .into_iter() + .find(|c| !c.contains("f_tenant_id")) +} + +/// 🔴 删除标记列(逻辑删除时用来排除已删行)。 +fn delete_mark_column(table: &sspf_lowcode::TableSchema) -> Option { + 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::(FORM).unwrap()["fields"].clone(), + "logicalDelete": true, + "useBusinessKey": true, + "businessKeyList": ["F_Code"], + "businessKeyTip": "业务编码已存在", + })) + .unwrap() + } + + fn model() -> ModelSchema { + ModelSchema::parse(&serde_json::from_str::(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::(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")); + } +} diff --git a/src/backend/src/lowcode_crud.rs b/src/backend/src/lowcode_crud.rs new file mode 100644 index 0000000..a11dc86 --- /dev/null +++ b/src/backend/src/lowcode_crud.rs @@ -0,0 +1,1240 @@ +//! lowcode_crud —— 内核侧的**低代码动态 CRUD 执行层**(P2-b)。 +//! +//! ## 分工 +//! +//! | 层 | 位置 | 干什么 | +//! |---|---|---| +//! | 解析 / 校验 / **SQL 生成** | `sspf-lowcode`(纯计算,AR7) | 出 SQL 文本 + 参数 | +//! | **执行** | 本文件(内核) | 连库、跑 SQL、返回结果 | +//! +//! ⇒ SQL 生成的正确性由 `sspf-lowcode` 的单测覆盖;本文件只做「拿到 SQL 就执行」, +//! 没有分支逻辑 —— 这是刻意的分工。 +//! +//! ## 🔴 四条执行层的硬约定 +//! +//! 1. **主表先行、子表随后**:子表外键指向主表主键,顺序反了会插不进去。 +//! 2. **一个事务**:主表失败 ⇒ 子表也不能留孤儿行。 +//! pglite 有真事务 API(`transaction()` / `commit()` / `rollback()`)—— 用它。 +//! 3. **写入前先比对真实库列**:设计稿自洽 ≠ 真实库有那列。 +//! 官方数据里 `columnName` 全是 null,列名是从 `field` 推导的 —— +//! 推导必然有偏差(`F_CreatorTime` → `f_creatortime`,真实列可能是别的)。 +//! ⇒ 落库前拿 `information_schema` 对一遍,**对不上就拒绝写**, +//! 并明确告诉 AI「设计稿与真实库不一致」。 +//! 4. **子表更新走差集对账**:不是全量覆盖(详见 [`sspf_lowcode::diff_sub_rows`])。 +//! +//! ## 🔴 为什么第 3 条不能省 +//! +//! 省掉它 ⇒ 数据库报 `column "f_xxx" does not exist` —— +//! 这句话对 AI 毫无指导性(该改表单?改表?还是拼错了?)。 +//! 自己做比对 ⇒ 报「设计稿声明了 f_xxx,但真实库没有这一列」, +//! 直接指到要改的地方。 +//! +//! ## 🔴 值的类型:走 `::text` + 显式 cast +//! +//! pglite 绑参数时若不指定类型,PG 会把 `$1` **推断成目标列的类型** +//! (`timestamp` / `numeric` / `integer`),而我们绑的是 `Option` +//! ⇒ 直接报 `cannot convert between the Rust type String and the Postgres type timestamp`。 +//! ⇒ 一律 `$n::text`,再按列类型加 cast(`::numeric` / `::integer` / `::timestamp`)。 +//! +//! ## 🔴 cast 靠 `param_columns`,不靠猜 +//! +//! [`sspf_lowcode::Sql`] 自带「占位符 ↔ 列名」映射 ⇒ 执行层不需要 +//! 「理解 SQL 是怎么拼的」,也不需要「按模型字段顺序猜第 n 个参数是哪一列」 +//! (写入列顺序 ≠ 模型字段顺序 —— 系统列是运行时追加的,猜错就写脏数据)。 + +use std::collections::BTreeMap; + +use pglite::ToSql; +use serde_json::{json, Value}; + +use sspf_lowcode::{ + check_identifier, plan_delete, plan_insert, plan_update_full, sql::Sql, FieldNode, FormSchema, + ModelSchema, SqlError, SubUpdateContext, SubUpdateOptions, TableSchema, WriteContext, +}; +use sspf_mcp::adapter::ToolError; + +use crate::platform::db::Db; +use crate::platform::ids::new_uuid; + +/// 🔴 **单租户**下的默认租户值。 +/// +/// ## 溯源 +/// +/// 基线平台 `GlobalConst`: +/// ```java +/// public static final String DEFAULT_TENANT_VALUE = "0"; +/// ``` +/// +/// `TenantDataSourceUtil.getTenantColumn()`: +/// ```java +/// public static String getTenantColumn() { +/// String result = GlobalConst.DEFAULT_TENANT_VALUE; +/// if (isTenantColumn()) { // 只有「字段隔离」模式才取真实租户名 +/// result = getTenantName(); +/// } +/// return result; +/// } +/// ``` +/// +/// 本平台部署配置 `config.MultiTenancy: false` ⇒ `isTenantColumn()` 为 false +/// ⇒ **恒定返回 `"0"`**。 +/// +/// ## 🔴 为什么单租户下**仍然要写**租户列 +/// +/// `FlowFormDataUtil.addTenantId()` 是**无条件**执行的: +/// ```java +/// private void addTenantId(GeneralInsertDSL dsl, SqlTable t) { +/// dsl.set(t.column(TableFeildsEnum.TENANTID.getField())) +/// .toValue(TenantDataSourceUtil.getTenantColumn()); +/// } +/// ``` +/// ⇒ 单租户也会往 `f_tenant_id` 写 `"0"`。 +/// 不写的话,列是 NOT NULL(`TableFeildsEnum.TENANTID` 的 nullSign = "NOT NULL") +/// ⇒ 插入直接失败。 +pub const DEFAULT_TENANT_ID: &str = "0"; + +/// 动态 CRUD 的执行结果。 +#[derive(Debug, Clone)] +pub struct CrudOutcome { + /// 主键 id。 + pub id: String, + /// 实际执行的 SQL 条数(主表 + 子表)。 + pub statements: usize, + /// 诊断信息(哪些列没写、为什么)。 + pub notes: Vec, + /// 计划好的 SQL(dry-run 时返回给调用方看)。 + pub sql: Vec, + /// 是否只是演练(没落库)。 + pub dry_run: bool, +} + +/// 把 lowcode 的错误转成结构化工具错误。 +pub fn sql_err(e: SqlError) -> ToolError { + let mut t = ToolError::new(e.code(), e.message()); + match &e { + SqlError::UnknownColumn { table, column } => { + t = t + .field(column) + .hint(format!( + "表 {table} 里没有列 {column};先 form.describe 看真实字段清单" + )) + .next( + "form.describe", + json!({ "enCode": "<功能编码>" }), + "看这个功能的字段与列", + ); + } + SqlError::MissingRequired { table, column, label } => { + t = t.field(column).hint(format!( + "必填字段「{label}」({table}.{column}) 必须给值;\ + 确实要留空就先把它从「必填」里去掉" + )); + } + SqlError::UnknownTable(tbl) => { + t = t + .field("table") + .hint(format!("表 {tbl} 不在功能定义里 —— 表名白名单不通过")) + .next( + "form.validate", + json!({ "enCode": "<功能编码>" }), + "先体检这个功能", + ); + } + SqlError::NoMainTable => { + t = t.hint("模型里没有 typeId=1 的主表 —— 这个功能定义可能不完整"); + } + SqlError::NoPrimaryKey(tbl) => { + t = t.hint(format!( + "表 {tbl} 缺主键:入参没给,且调用方没生成 —— \ + 子表每行的主键需要调用方预先生成并登记" + )); + } + SqlError::TypeMismatch { column, expected } => { + t = t.field(column).hint(format!("字段 {column} 应为 {expected}")); + } + SqlError::UnsupportedValue { column } => { + t = t.field(column).hint(format!( + "字段 {column} 的值是复杂对象 —— 只能给字符串/数字/数组;\ + 对象请先序列化成 JSON 字符串" + )); + } + SqlError::IllegalIdentifier { kind, value } => { + t = t.hint(format!( + "{kind}「{value}」含非法字符,只能是字母/数字/下划线" + )); + } + SqlError::NoColumnsToUpdate(tbl) => { + t = t.hint(format!( + "表 {tbl} 没有任何列要更新 —— 入参没给可写字段,或给的都是系统字段" + )); + } + SqlError::MissingRelationValue { table, column } => { + t = t.hint(format!( + "子表 {table} 的外键指向主表的 {column},但这一列的值拿不到 —— \ + 它不是主键,需要先查出来再传进来" + )); + } + SqlError::LogicalDeleteUnsupported(tbl) => { + t = t.hint(format!( + "表 {tbl} 没有删除标记列,不支持逻辑删除 —— \ + 这个功能要么该走物理删除,要么表建错了(logicalDelete 与建表不匹配)" + )) + .next( + "form.validate", + json!({ "enCode": "<功能编码>" }), + "体检这个功能的逻辑删除设置", + ); + } + } + t +} + +/// 🔴 设计稿 vs 真实库:列名比对结果。 +#[derive(Debug, Clone, PartialEq)] +pub struct ColumnMismatch { + /// 真实库里缺的设计稿列。 + pub missing: Vec, + /// 真实库有、但设计稿没声明的列(通常是系统列,不算错,仅供参考)。 + pub extra: Vec, +} + +/// 取一张表在真实库里的列名。 +pub async fn real_columns(db: &Db, table: &str) -> Result, ToolError> { + let t = table.to_string(); + let rows = db + .query_json_params( + "SELECT column_name AS \"name\" FROM information_schema.columns \ + WHERE table_schema = 'public' AND table_name = $1 \ + ORDER BY ordinal_position", + &[&t], + ) + .await + .map_err(|e| { + ToolError::new("DB_ERROR", format!("读表结构失败: {e}")) + .hint("先 schema.table.list 确认表在不在") + .retryable() + })?; + Ok(rows + .into_iter() + .filter_map(|r| r["name"].as_str().map(str::to_string)) + .collect()) +} + +/// 比对设计稿声明的列与真实库的列。 +pub fn compare_columns(declared: &[String], actual: &[String]) -> ColumnMismatch { + let actual_lower: Vec = actual.iter().map(|c| c.to_lowercase()).collect(); + let missing: Vec = declared + .iter() + .filter(|c| !actual_lower.contains(&c.to_lowercase())) + .cloned() + .collect(); + let declared_lower: Vec = declared.iter().map(|c| c.to_lowercase()).collect(); + let extra: Vec = actual + .iter() + .filter(|c| !declared_lower.contains(&c.to_lowercase())) + .cloned() + .collect(); + ColumnMismatch { missing, extra } +} + +/// 🔴 真实库里**根本没有这张表**时的错误。 +pub fn table_missing_error(table: &str) -> ToolError { + ToolError::new("TABLE_NOT_IN_DB", format!("真实库里没有表 {table}")).field("table").hint( + "设计稿里的表还没建出来 —— 低代码功能要先「建表」再「存数据」。\ + 用 schema.table.list 看当前库有哪些表", + ) + .next( + "schema.table.list", + json!({ "prefix": table }), + "看这张表在不在", + ) +} + +/// 构造写入上下文(把内核有的东西塞进去)。 +pub fn build_context( + user_id: Option<&str>, + tenant_id: Option<&str>, + now: Option<&str>, +) -> WriteContext { + WriteContext { + user_id: user_id.map(str::to_string), + organize_ids: Vec::new(), + position_ids: Vec::new(), + tenant_id: tenant_id.map(str::to_string), + bill_numbers: Default::default(), + primary_keys: Default::default(), + now: now.map(str::to_string), + relation_values: Default::default(), + } +} + +/// 🔴 当前时间(ISO8601,秒精度)。 +/// +/// 🔴 为什么用**秒精度**而不是毫秒/纳秒: +/// 低代码表的 `f_creatortime` / `f_lastmodifytime` 在官方 DDL 里是 +/// `timestamp`(**没有时区**)⇒ 传 ISO 带 `T` 和 `Z` 的串会被 PG +/// 解析成 `timestamptz` 再转 `timestamp` ⇒ **会随时区偏移几个小时**。 +/// 统一给 `YYYY-MM-DD HH:MM:SS` 最稳(PG 直接当 timestamp 字面量)。 +pub fn now_iso() -> String { + chrono::Local::now() + .format("%Y-%m-%d %H:%M:%S") + .to_string() +} + +/// 执行一次**新增**(主表 + 子表),全部落在一个事务里。 +/// +/// `dry_run = true` ⇒ 只生成 SQL + 校验列,**不落库**。 +pub async fn insert_record( + db: &Db, + form: &FormSchema, + model: &ModelSchema, + payload: &Value, + ctx: &mut WriteContext, + dry_run: bool, +) -> Result { + let main_table = model.main_table().ok_or_else(|| { + ToolError::new("NO_MAIN_TABLE", "模型里没有主表(typeId=1)") + .hint("这个功能定义不完整") + })?; + let main_name = main_table.table.clone(); + + // 🔴 落库前先确认表在真实库里 + let real = real_columns(db, &main_name).await?; + if real.is_empty() { + return Err(table_missing_error(&main_name)); + } + + // 生成主键 + let main_id = new_uuid(); + ctx.set_primary_key(main_name.clone(), main_id.clone()); + + // 子表每行也要主键(Java 侧服务端现生成 UUID) + for sub in form.sub_tables() { + let Some(sub_model) = resolve_sub_model(model, sub) else { + continue; + }; + let rows = sub_rows(payload, &sub.v_model, &sub_model.table); + let Some(arr) = rows.as_ref().and_then(|v| v.as_array()) else { + continue; + }; + for i in 0..arr.len() { + let key = new_uuid(); + ctx.set_sub_row_key(&sub_model.table, &main_id, i, key); + } + } + + let plan = plan_insert(form, model, payload, ctx, &main_id).map_err(sql_err)?; + + // 🔴 逐条比对真实库列 —— 对不上就**拒绝写**,而不是让数据库报错 + let mut notes: Vec = Vec::new(); + let mut real_cols: Vec<(String, Vec)> = Vec::new(); + for stmt in plan.all() { + let cols = columns_of_sql(&stmt.text); + let actual = match real_cols.iter().find(|(t, _)| t == &stmt.table) { + Some((_, c)) => c.clone(), + None => { + let a = real_columns(db, &stmt.table).await?; + if a.is_empty() { + return Err(table_missing_error(&stmt.table)); + } + real_cols.push((stmt.table.clone(), a.clone())); + a + } + }; + let diff = compare_columns(&cols, &actual); + if !diff.missing.is_empty() { + return Err(column_mismatch_error(&stmt.table, &diff, &actual)); + } + if !diff.extra.is_empty() { + notes.push(format!( + "表 {} 真实库里还有设计稿没声明的列(未写入):{}", + stmt.table, + diff.extra.join(", ") + )); + } + } + + let stmts: Vec = plan.all().into_iter().cloned().collect(); + + // 🔴 **业务校验**(唯一性 / 业务主键)—— 必须在真正写库**之前**做。 + // + // 基线平台 `VisualdevModelDataServiceImpl.visualCreate()`: + // ```java + // String b = formCheckUtils.checkForm(checkFormModel); + // if (StringUtil.isNotEmpty(b)) { throw new WorkFlowException(b); } + // flowFormDataUtil.create(dataModel); + // ``` + // ⇒ 校验失败 ⇒ **一条 SQL 都不执行**。 + // + // dry-run 也要做校验:dry-run 的意义是「先看会不会被拦」。 + // 校验不过还返回 SQL,AI 会误以为「只差一步就能落库」。 + // + // 新增场景 `record_id = None` ⇒ 不排除任何行。 + crate::lowcode_check::check_unique_fields(db, form, model, payload, None).await?; + crate::lowcode_check::check_business_key(db, form, model, payload, None).await?; + + if dry_run { + return Ok(CrudOutcome { + id: main_id, + statements: stmts.len(), + notes, + sql: stmts, + dry_run: true, + }); + } + + let count = execute_plan(db, model, &stmts).await?; + + Ok(CrudOutcome { + id: main_id, + statements: count, + notes, + sql: stmts, + dry_run: false, + }) +} + +/// 🔴 记录不存在的错误(AI 据此自纠:先查再改)。 +pub fn record_missing_error(table: &str, record_id: &str) -> ToolError { + ToolError::new( + "RECORD_NOT_FOUND", + format!("表 {table} 里没有 id 为 {record_id} 的记录"), + ) + .field("recordId") + .hint("记录可能已被删除;先用 data.query 查一遍确认 id") + .next( + "data.query", + json!({ "enCode": "<功能编码>" }), + "查这条记录还在不在", + ) +} + +/// 执行一次**更新**(主表 + 子表差集对账)。 +/// +/// ## 🔴 `only_update` 的口径(对齐基线平台) +/// +/// 基线平台 `DataModel.onlyUpdate`: +/// ```java +/// // 子表仅修改 +/// private Boolean onlyUpdate = false; +/// ``` +/// ```java +/// if (CollUtil.isNotEmpty(deleteList) && !onlyUpdate) { /* 删缺失的旧行 */ } +/// ``` +/// +/// ⇒ `onlyUpdate = true` ⇒ **不删**入参里缺失的旧行(只更新/新增)。 +/// +/// 🔴 **基线的正常 HTTP 路径恒为 false**: +/// `VisualdevModelDataController` 构造 `VisualParamModel` 时**没有**设 `onlyUpdate` +/// ⇒ 只有 Excel 导入(`OnlineExcelUtil`)与流程场景才可能为 true。 +/// ⇒ 本函数默认 `false`,MCP 层**不暴露**这个开关(暴露了会让 AI 以为 +/// 「默认只更新不删除」,与基线的实际行为相反)。 +#[allow(clippy::too_many_arguments)] +pub async fn update_record( + db: &Db, + form: &FormSchema, + model: &ModelSchema, + payload: &Value, + ctx: &mut WriteContext, + record_id: &str, + dry_run: bool, +) -> Result { + update_record_with(db, form, model, payload, ctx, record_id, dry_run, false).await +} + +/// 带 `only_update` 的更新(默认路径走 [`update_record`])。 +#[allow(clippy::too_many_arguments)] +pub async fn update_record_with( + db: &Db, + form: &FormSchema, + model: &ModelSchema, + payload: &Value, + ctx: &mut WriteContext, + record_id: &str, + dry_run: bool, + only_update: bool, +) -> Result { + let main_table = model.main_table().ok_or_else(|| { + ToolError::new("NO_MAIN_TABLE", "模型里没有主表(typeId=1)") + })?; + let main_name = main_table.table.clone(); + + let real = real_columns(db, &main_name).await?; + if real.is_empty() { + return Err(table_missing_error(&main_name)); + } + + // 🔴 **先确认记录存在** —— 否则错误会一路飘到子表查询上, + // 变成一句毫无指导性的 `DB_ERROR`(AI 不知道是「记录没了」还是「库坏了」)。 + ensure_record_exists(db, model, record_id).await?; + + // 🔴 **顺序很重要**:先查主表那一行的**关联列实际值**,再收集子表上下文。 + // + // 子表外键的值 = 主表 `relationField` 指向的那一列的值 + // (基线平台:`mainMap.get(table.getRelationField())`)。 + // 当 `relationField` 就是主键时,值 = 主键,收集子表上下文时回落到 `record_id` 没问题; + // 但当它指向**别的列**(如业务编码 `F_Code`)时, + // 不先查库就拿不到值 ⇒ 外键会退化成主键 ⇒ 子表挂错父行。 + // + // 之前顺序反了(先 collect 再 fetch)⇒ 非主键 relationField 场景下 + // `collect_sub_contexts` 拿不到关联值,回落成 `main_id`。 + let relation_values = fetch_relation_values(db, form, model, record_id).await?; + for (col, val) in &relation_values { + ctx.set_relation_value(col, val.clone()); + } + + // 🔴 子表差集需要「旧行主键」—— 查库在**事务外**做(避免持锁期间再开事务死锁)。 + let logical = form.logical_delete.unwrap_or(false); + let sub_ctxs = collect_sub_contexts(db, form, model, ctx, record_id, logical, only_update).await?; + + let plan = plan_update_full(form, model, payload, ctx, record_id, &sub_ctxs).map_err(sql_err)?; + + let mut notes: Vec = Vec::new(); + let mut real_cols: Vec<(String, Vec)> = Vec::new(); + for stmt in plan.all() { + let cols = columns_of_sql(&stmt.text); + if cols.is_empty() { + continue; + } + let actual = match real_cols.iter().find(|(t, _)| t == &stmt.table) { + Some((_, c)) => c.clone(), + None => { + let a = real_columns(db, &stmt.table).await?; + if a.is_empty() { + return Err(table_missing_error(&stmt.table)); + } + real_cols.push((stmt.table.clone(), a.clone())); + a + } + }; + let diff = compare_columns(&cols, &actual); + if !diff.missing.is_empty() { + return Err(column_mismatch_error(&stmt.table, &diff, &actual)); + } + if !diff.extra.is_empty() { + notes.push(format!( + "表 {} 真实库里还有设计稿没声明的列(未写入):{}", + stmt.table, + diff.extra.join(", ") + )); + } + } + + let stmts: Vec = plan.all().into_iter().cloned().collect(); + + // 🔴 **业务校验**(唯一性 / 业务主键)—— 更新场景要**排除自己那行**。 + // + // 基线平台 `FormCheckUtils` 的唯一性 SQL: + // ```java + // if (StringUtils.isNotEmpty(id)) { + // where.and(sqlTable.column(mainKeyModel.getField()), SqlBuilder.isNotEqualTo(realId)); + // } + // ``` + // ⇒ 不排除自己 ⇒ 改一下别的字段也会被判「重复」。 + crate::lowcode_check::check_unique_fields(db, form, model, payload, Some(record_id)).await?; + crate::lowcode_check::check_business_key(db, form, model, payload, Some(record_id)).await?; + + if dry_run { + return Ok(CrudOutcome { + id: record_id.to_string(), + statements: stmts.len(), + notes, + sql: stmts, + dry_run: true, + }); + } + + let count = execute_plan(db, model, &stmts).await?; + + Ok(CrudOutcome { + id: record_id.to_string(), + statements: count, + notes, + sql: stmts, + dry_run: false, + }) +} + +/// 执行一次**删除**(逻辑 / 物理按 `form.logicalDelete`)。 +pub async fn delete_record( + db: &Db, + form: &FormSchema, + model: &ModelSchema, + ctx: &mut WriteContext, + record_id: &str, + dry_run: bool, +) -> Result { + let main_table = model.main_table().ok_or_else(|| { + ToolError::new("NO_MAIN_TABLE", "模型里没有主表(typeId=1)") + })?; + let main_name = main_table.table.clone(); + + let real = real_columns(db, &main_name).await?; + if real.is_empty() { + return Err(table_missing_error(&main_name)); + } + + // 🔴 先确认记录存在(否则错误会飘到子表查询上,变成没指导性的 DB_ERROR)。 + ensure_record_exists(db, model, record_id).await?; + + let logical = form.logical_delete.unwrap_or(false); + + // 🔴 子表外键的值可能不是主键(`relationField` 指向别的列)⇒ 先查主表那一行。 + let relation_values = fetch_relation_values(db, form, model, record_id).await?; + for (col, val) in &relation_values { + ctx.set_relation_value(col, val.clone()); + } + + // 逻辑删除但表里没有删除列 ⇒ `plan_delete` 会报 `LOGICAL_DELETE_UNSUPPORTED`。 + // 那种情况**不退化成物理删**(用户以为逻辑删了,实际物理删 ⇒ 审计链断)。 + let plan = plan_delete(form, model, ctx, record_id).map_err(sql_err)?; + + let mut notes: Vec = Vec::new(); + let mut real_cols: Vec<(String, Vec)> = Vec::new(); + for stmt in plan.all() { + let cols = columns_of_sql(&stmt.text); + if cols.is_empty() { + continue; + } + let actual = match real_cols.iter().find(|(t, _)| t == &stmt.table) { + Some((_, c)) => c.clone(), + None => { + let a = real_columns(db, &stmt.table).await?; + if a.is_empty() { + return Err(table_missing_error(&stmt.table)); + } + real_cols.push((stmt.table.clone(), a.clone())); + a + } + }; + let diff = compare_columns(&cols, &actual); + if !diff.missing.is_empty() { + return Err(column_mismatch_error(&stmt.table, &diff, &actual)); + } + if !diff.extra.is_empty() { + notes.push(format!( + "表 {} 真实库里还有设计稿没声明的列(未写入):{}", + stmt.table, + diff.extra.join(", ") + )); + } + } + + notes.push(if logical { + "逻辑删除:置删除标记,数据仍在表里".to_string() + } else { + "物理删除:行会真从表里消失(logicalDelete=false)".to_string() + }); + + let stmts: Vec = plan.all().into_iter().cloned().collect(); + + if dry_run { + return Ok(CrudOutcome { + id: record_id.to_string(), + statements: stmts.len(), + notes, + sql: stmts, + dry_run: true, + }); + } + + let count = execute_plan(db, model, &stmts).await?; + + Ok(CrudOutcome { + id: record_id.to_string(), + statements: count, + notes, + sql: stmts, + dry_run: false, + }) +} + +/// 🔴 确认主记录存在(更新 / 删除前必查)。 +/// +/// ## 为什么必须单独查一次 +/// +/// 更新流程后面会去查子表旧行、关联列值 —— 那些查询用的都是 `record_id`。 +/// 记录不存在时,错误会飘到子表查询上,变成一句 +/// `DB_ERROR: 查子表旧行失败: relation "xxx" does not exist` —— +/// AI 看到完全不知道是「记录没了」还是「库坏了」。 +/// +/// ⇒ 先明确报 `RECORD_NOT_FOUND`,并提示「先用 data.query 查一遍」。 +/// +/// ## 🔴 主键列**从模型推导**,不写死 `f_id` +/// +/// Java `getKey()`:取模型里 `primaryKey=1` 且**不是租户列**的那一列。 +/// 官方模型里 `f_tenant_id` 也是 `primaryKey=1` ⇒ 必须排除。 +async fn ensure_record_exists( + db: &Db, + model: &ModelSchema, + record_id: &str, +) -> Result<(), ToolError> { + let Some(main_table) = model.main_table() else { + return Ok(()); + }; + let table = main_table.table.clone(); + let pk_col = main_table + .primary_keys() + .into_iter() + .find(|c| !c.contains("f_tenant_id")) + .unwrap_or_else(|| "f_id".to_string()); + + // 🔴 表名/列名来自用户可编辑的模型 JSON ⇒ 进 SQL 前过标识符检查。 + check_identifier("表名", &table).map_err(sql_err)?; + check_identifier("列名", &pk_col).map_err(sql_err)?; + + let id = record_id.to_string(); + let sql = format!("SELECT {pk_col} AS \"id\" FROM {table} WHERE {pk_col} = $1 LIMIT 1"); + let rows = db + .query_json_params(&sql, &[&id]) + .await + .map_err(|e| ToolError::new("DB_ERROR", format!("查记录失败: {e}")).retryable())?; + if rows.is_empty() { + return Err(record_missing_error(&table, record_id)); + } + Ok(()) +} + +/// 🔴 收集子表更新的上下文(**旧行主键**从库里查)。 +/// +/// 差集对账的前提是知道「旧库里有哪些行」。 +/// 本函数是**纯查库**(不改数据)⇒ 放在事务外执行,避免持锁期间再开事务。 +async fn collect_sub_contexts( + db: &Db, + form: &FormSchema, + model: &ModelSchema, + ctx: &WriteContext, + main_id: &str, + logical: bool, + only_update: bool, +) -> Result, ToolError> { + let mut out: BTreeMap = BTreeMap::new(); + + for sub in form.sub_tables() { + let Some(sub_model) = resolve_sub_model(model, sub) else { + continue; + }; + let Some(fk_col) = sub_model.foreign_key_column() else { + return Err(sql_err(SqlError::UnknownColumn { + table: sub_model.table.clone(), + column: "tableField".to_string(), + })); + }; + let sub_pk = sub_model + .primary_keys() + .into_iter() + .find(|c| !c.contains("f_tenant_id")) + .unwrap_or_else(|| "f_id".to_string()); + + // 🔴 表名/列名进 SQL 之前必须过标识符检查。 + // + // 这些名字来自**用户可编辑的模型 JSON**(`f_tables_data`)。 + // 参数化只能防「值注入」,**防不住结构注入** —— + // 表名/列名是拼进 SQL 文本的,不是占位符。 + // ⇒ 规则与生成层共用同一份(`sspf_lowcode::check_identifier`), + // 避免「生成层拦了、执行层漏了」的漏洞。 + for (kind, name) in [ + ("表名", sub_model.table.as_str()), + ("列名", fk_col.as_str()), + ("列名", sub_pk.as_str()), + ] { + check_identifier(kind, name).map_err(sql_err)?; + } + + // 外键的值:主表 `relationField` 指向的那一列的实际值。 + let fk_value = ctx + .relation_value(sub_model) + .unwrap_or_else(|| main_id.to_string()); + + // 查旧行主键 + let sql = format!( + "SELECT {sub_pk} AS \"k\" FROM {table} WHERE {fk_col} = $1", + sub_pk = sub_pk, + table = sub_model.table, + fk_col = fk_col, + ); + let rows = db + .query_json_params(&sql, &[&fk_value]) + .await + .map_err(|e| { + ToolError::new("DB_ERROR", format!("查子表旧行失败: {e}")) + .hint("子表可能还没建出来") + .retryable() + })?; + let old_keys: Vec = rows + .into_iter() + .filter_map(|r| r["k"].as_str().map(str::to_string)) + .collect(); + + let mut sub_ctx = SubUpdateContext::new( + old_keys, + fk_col.clone(), + fk_value, + SubUpdateOptions { + only_update, + logical_delete: logical, + }, + ); + // 🔴 子表行主键由内核生成(Java 侧是 `RandomUtil.uuId()`)。 + sub_ctx.row_key_generator = Some(|_| new_uuid()); + out.insert(sub_model.table.clone(), sub_ctx); + } + + Ok(out) +} + +/// 🔴 查主表那一行的**关联列**实际值(子表外键要指向它)。 +/// +/// 基线平台:`Object relationFieldValue = mainMap.get(table.getRelationField());` +/// —— 读的是**主表那一行的实际值**,不是主键。 +/// +/// `relationField` 通常就是主键列 ⇒ 这次查询走的是「白名单内的表名 + 白名单内的列名」。 +async fn fetch_relation_values( + db: &Db, + form: &FormSchema, + model: &ModelSchema, + main_id: &str, +) -> Result, ToolError> { + let Some(main_table) = model.main_table() else { + return Ok(Vec::new()); + }; + let main_pk = main_table + .primary_keys() + .into_iter() + .find(|c| !c.contains("f_tenant_id")) + .unwrap_or_else(|| "f_id".to_string()); + + // 🔴 表名/主键列名进 SQL 之前必须过标识符检查(同 [`collect_sub_contexts`])。 + check_identifier("表名", &main_table.table).map_err(sql_err)?; + check_identifier("列名", &main_pk).map_err(sql_err)?; + + // 收集所有子表用到的关联列 + let mut cols: Vec = Vec::new(); + for sub in form.sub_tables() { + let Some(sub_model) = resolve_sub_model(model, sub) else { + continue; + }; + if let Some(rel) = sub_model.relation_column() { + // 🔴 关联列名同样来自用户可编辑的模型 JSON ⇒ 也要过检查。 + check_identifier("列名", &rel).map_err(sql_err)?; + if !cols.contains(&rel) { + cols.push(rel); + } + } + } + if cols.is_empty() { + return Ok(Vec::new()); + } + + // 一次查出来 + let sel: Vec = cols.iter().map(|c| format!("{c} AS \"{c}\"")).collect(); + let sql = format!( + "SELECT {} FROM {} WHERE {} = $1", + sel.join(", "), + main_table.table, + main_pk + ); + let rows = db + .query_json_params(&sql, &[&main_id.to_string()]) + .await + .map_err(|e| { + ToolError::new("DB_ERROR", format!("查主表关联列失败: {e}")).retryable() + })?; + + let Some(row) = rows.first() else { + return Ok(Vec::new()); + }; + + let mut out = Vec::new(); + for c in cols { + if let Some(v) = row.get(&c) { + let text = match v { + Value::String(s) => s.clone(), + Value::Null => continue, + other => other.to_string(), + }; + out.push((c, text)); + } + } + Ok(out) +} + +/// 🔴 在一个事务里执行整组 SQL。 +/// +/// pglite 的 `transaction()` 会拿**独占锁**(`lock_for_transaction`), +/// 所以事务期间不会有别的请求插进来 —— 不会出现「A 写了主表、B 改了子表」的交错。 +async fn execute_plan( + db: &Db, + model: &ModelSchema, + stmts: &[Sql], +) -> Result { + if stmts.is_empty() { + return Ok(0); + } + let tx = db.begin().await.map_err(|e| { + ToolError::new("DB_ERROR", format!("开事务失败: {e}")).retryable() + })?; + + for stmt in stmts { + let table = model.table(&stmt.table); + let sql_text = render_with_casts(&stmt.text, &stmt.params, &stmt.param_columns, table); + let params = params_as_text(&stmt.params); + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + + if let Err(e) = tx.exec_params(&sql_text, &refs).await { + let _ = tx.rollback().await; + return Err(ToolError::new("DB_ERROR", format!("写库失败: {e}")) + .hint("多半是列名与真实表对不上;先 form.validate 再看真实表的列") + .retryable()); + } + } + + tx.commit().await.map_err(|e| { + ToolError::new("DB_ERROR", format!("提交事务失败: {e}")).retryable() + })?; + + Ok(stmts.len()) +} + +/// 🔴 列不一致时的结构化错误。 +fn column_mismatch_error( + table: &str, + diff: &ColumnMismatch, + actual: &[String], +) -> ToolError { + ToolError::new( + "COLUMN_MISMATCH", + format!( + "表 {} 缺少设计稿声明的列:{}", + table, + diff.missing.join(", ") + ), + ) + .field(diff.missing.first().map(|s| s.as_str()).unwrap_or("")) + .hint(format!( + "真实库里 {} 只有这些列:{}。\ + 设计稿的列名是从 `field` 推导的(官方数据 columnName 全是 null),\ + 推导必然有偏差 —— 要么改设计稿,要么改真实表", + table, + actual.join(", ") + )) + .next( + "form.validate", + json!({ "enCode": "<功能编码>" }), + "体检设计稿自洽性", + ) +} + +/// 把 `$n` 占位符改成 `$n::text` + 类型 cast。 +/// +/// 🔴 必须加 `::text`:pglite 绑 `Option`, +/// 若让 PG 把 `$1` 推断成 `timestamp` / `numeric`,会直接报 +/// `cannot convert between the Rust type String and the Postgres type timestamp`。 +/// +/// 🔴 占位符必须**按完整 token 扫描**:`$1` 是 `$10` 的前缀, +/// 用字符串 find 会把 `$10` 改成 `$1::text0::text`。 +/// +/// 🔴 cast 靠 `param_columns`(占位符 ↔ 列名的一一映射), +/// **不猜**「第 n 个参数是哪一列」。 +fn render_with_casts( + text: &str, + params: &[Value], + param_columns: &[String], + table: Option<&TableSchema>, +) -> String { + let mut out = String::with_capacity(text.len() + params.len() * 8); + let bytes = text.as_bytes(); + let mut i = 0usize; + + while i < bytes.len() { + if bytes[i] == b'$' { + // 读数字 + let mut j = i + 1; + while j < bytes.len() && bytes[j].is_ascii_digit() { + j += 1; + } + if j > i + 1 { + let idx: usize = text[i + 1..j].parse().unwrap_or(0); + out.push_str(&text[i..j]); + out.push_str("::text"); + if let Some(col) = param_columns.get(idx.saturating_sub(1)) { + out.push_str(cast_of_type(col, table)); + } + i = j; + continue; + } + } + let ch_len = utf8_len(bytes[i]); + out.push_str(&text[i..i + ch_len]); + i += ch_len; + } + out +} + +/// 取一个 UTF-8 字符的字节长度。 +fn utf8_len(b: u8) -> usize { + if b < 0x80 { + 1 + } else if b >> 5 == 0b110 { + 2 + } else if b >> 4 == 0b1110 { + 3 + } else if b >> 3 == 0b11110 { + 4 + } else { + 1 + } +} + +/// 按列名给出写值时的 cast。 +fn cast_of_type(column: &str, table: Option<&TableSchema>) -> &'static str { + let Some(table) = table else { + return ""; + }; + // 先看模型里声明的数据类型 + if let Some(def) = table.column_by_name(column) { + match def.data_type.to_lowercase().as_str() { + "int" | "integer" | "int2" | "int4" | "int8" | "bigint" | "smallint" => { + return "::integer" + } + "decimal" | "numeric" | "money" | "real" | "double" | "float" => return "::numeric", + "datetime" | "timestamp" | "date" | "time" => return "::timestamp", + "bool" | "boolean" => return "::boolean", + _ => {} + } + } + // 模型没说 ⇒ 按列名特征兜底 + let lower = column.to_lowercase(); + if lower.ends_with("_time") || lower.ends_with("_date") || lower.ends_with("time") { + return "::timestamp"; + } + "" +} + +/// 值 ⇒ `Option`(绑定用)。 +/// +/// 🔴 一律按**文本**传 —— 类型转换交给 SQL 里的 `::text` + cast 链。 +fn params_as_text(values: &[Value]) -> Vec> { + values + .iter() + .map(|v| match v { + Value::Null => None, + Value::String(s) => Some(s.clone()), + Value::Number(n) => Some(n.to_string()), + Value::Bool(b) => Some(b.to_string()), + other => Some(other.to_string()), + }) + .collect() +} + +/// 从一条 SQL 里取出列名。 +fn columns_of_sql(text: &str) -> Vec { + if let Some((_, rest)) = text.split_once(" (") { + if let Some((cols, _)) = rest.split_once(") VALUES") { + return cols.split(", ").map(|s| s.to_string()).collect(); + } + } + if let Some((_, rest)) = text.split_once(" SET ") { + if let Some((sets, _)) = rest.split_once(" WHERE ") { + return sets + .split(", ") + .filter_map(|s| s.split(" = ").next()) + .map(|s| s.to_string()) + .collect(); + } + } + Vec::new() +} + +/// 找出子表节点对应的模型表。 +fn resolve_sub_model<'a>( + model: &'a ModelSchema, + sub: &FieldNode, +) -> Option<&'a TableSchema> { + if let Some(name) = sub.table_name.as_deref() { + if let Some(t) = model.table(name) { + return Some(t); + } + } + for child in &sub.children { + if let Some(rt) = child.relation_table.as_deref() { + if let Some(t) = model.table(rt) { + return Some(t); + } + } + } + let subs = model.sub_tables(); + if subs.len() == 1 { + Some(subs[0]) + } else { + None + } +} + +/// 从 payload 里取子表行数组。 +fn sub_rows(payload: &Value, v_model: &str, table: &str) -> Option { + let obj = payload.as_object()?; + if let Some(v) = obj.get(v_model) { + return Some(v.clone()); + } + for (k, v) in obj { + if k.eq_ignore_ascii_case(v_model) || k.eq_ignore_ascii_case(table) { + return Some(v.clone()); + } + } + None +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 🔴 比对必须能抓出「设计稿有、真实库没有」的列。 + #[test] + fn compare_columns_finds_missing() { + let declared = vec!["f_id".to_string(), "f_room".to_string()]; + let actual = vec!["f_id".to_string()]; + let diff = compare_columns(&declared, &actual); + assert_eq!(diff.missing, vec!["f_room".to_string()]); + assert!(diff.extra.is_empty()); + } + + /// 大小写不敏感(PG 会折叠大小写)。 + #[test] + fn compare_columns_is_case_insensitive() { + let declared = vec!["F_ID".to_string()]; + let actual = vec!["f_id".to_string()]; + let diff = compare_columns(&declared, &actual); + assert!(diff.missing.is_empty(), "不该报缺列: {:?}", diff.missing); + } + + /// 🔴 占位符必须加 `::text` —— 否则 PG 推断成 timestamp/numeric 会报类型错。 + #[test] + fn placeholders_get_text_cast() { + let out = render_with_casts( + "INSERT INTO t (a, b) VALUES ($1, $2)", + &[Value::String("x".into()), Value::String("y".into())], + &["a".to_string(), "b".to_string()], + None, + ); + assert_eq!(out, "INSERT INTO t (a, b) VALUES ($1::text, $2::text)"); + } + + /// 数值列要加 `::numeric`。 + #[test] + fn numeric_column_gets_numeric_cast() { + let model = ModelSchema::from_str( + r#"[{ "table": "t", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": "f_id", "primaryKey": 1 }, + { "field": "F_Price", "columnName": "f_price", "dataType": "decimal" } + ]}]"#, + ) + .unwrap(); + let table = model.table("t").unwrap(); + let out = render_with_casts( + "INSERT INTO t (f_id, f_price) VALUES ($1, $2)", + &[Value::String("a".into()), Value::String("9.9".into())], + &["f_id".to_string(), "f_price".to_string()], + Some(table), + ); + assert!( + out.contains("$2::text::numeric"), + "数值列应带 ::numeric: {out}" + ); + } + + /// 🔴 **`$10` 不能被 `$1` 的替换误伤**。 + /// + /// 用 `str::find("$1")` 找位置会把 `$10` 当成 `$1` ⇒ 变成 `$1::text0::text` + /// ⇒ SQL 直接语法错。这是最难查的一类 bug(只在参数 ≥ 10 时出现)。 + #[test] + fn ten_placeholders_are_not_corrupted_by_one() { + // 构造:INSERT INTO t (c1, ..., c10) VALUES ($1, ..., $10) + let mut text = String::from("INSERT INTO t ("); + for i in 1..=10 { + if i > 1 { + text.push_str(", "); + } + text.push_str(&format!("c{i}")); + } + text.push_str(") VALUES ("); + for i in 1..=10 { + if i > 1 { + text.push_str(", "); + } + text.push_str(&format!("${i}")); + } + text.push(')'); + + let params: Vec = (1..=10).map(|i| Value::String(format!("v{i}"))).collect(); + let cols: Vec = (1..=10).map(|i| format!("c{i}")).collect(); + + let out = render_with_casts(&text, ¶ms, &cols, None); + assert!( + out.contains("$10::text"), + "$10 应被完整替换: {out}" + ); + assert!( + !out.contains("$1::text0"), + "$10 被 $1 的替换误伤了: {out}" + ); + assert_eq!( + out.matches("::text").count(), + 10, + "应有 10 处 ::text: {out}" + ); + } + + /// 值转 `Option`:null ⇒ None。 + #[test] + fn params_as_text_maps_null_to_none() { + let vals = params_as_text(&[ + Value::Null, + Value::String("a".into()), + Value::Number(5.into()), + Value::Bool(true), + ]); + assert_eq!(vals[0], None); + assert_eq!(vals[1].as_deref(), Some("a")); + assert_eq!(vals[2].as_deref(), Some("5")); + assert_eq!(vals[3].as_deref(), Some("true")); + } + + /// 从 SQL 文本抽列名(INSERT / UPDATE 两种形态)。 + #[test] + fn columns_of_sql_handles_both_shapes() { + let ins = "INSERT INTO t (a, b, c) VALUES ($1, $2, $3)"; + assert_eq!(columns_of_sql(ins), vec!["a", "b", "c"]); + let upd = "UPDATE t SET a = $1, b = $2 WHERE id = $3"; + assert_eq!(columns_of_sql(upd), vec!["a", "b"]); + } + + /// 🔴 cast 必须靠 **列名**,不是靠「参数序号 = 模型字段序号」。 + #[test] + fn cast_uses_param_columns_not_position() { + let model = ModelSchema::from_str( + r#"[{ "table": "t", "typeId": "1", "fields": [ + { "field": "F_Id", "columnName": "f_id", "primaryKey": 1 }, + { "field": "F_Amount", "columnName": "f_amount", "dataType": "decimal" } + ]}]"#, + ) + .unwrap(); + let table = model.table("t").unwrap(); + // 参数顺序与模型字段顺序**故意不同**:$1 是 f_amount,$2 是 f_id + let out = render_with_casts( + "INSERT INTO t (f_amount, f_id) VALUES ($1, $2)", + &[Value::String("9.9".into()), Value::String("id".into())], + &["f_amount".to_string(), "f_id".to_string()], + Some(table), + ); + assert!( + out.contains("$1::text::numeric"), + "$1 是 f_amount,应带 ::numeric: {out}" + ); + assert!( + out.contains("$2::text") && !out.contains("$2::text::numeric"), + "$2 是 f_id,不该带 ::numeric: {out}" + ); + } +} diff --git a/src/backend/src/lowcode_ddl.rs b/src/backend/src/lowcode_ddl.rs new file mode 100644 index 0000000..da623ee --- /dev/null +++ b/src/backend/src/lowcode_ddl.rs @@ -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, + /// 哪些表是**已存在**因而跳过的。 + pub skipped: Vec, + /// 回写后的模型(`f_tables_data` 的新值)。 + pub model: Value, + /// 诊断信息。 + pub notes: Vec, + /// 实际执行的 DDL(dry-run 时给调用方看)。 + pub ddl: Vec, + /// 是否只是演练(没建表、没回写)。 + 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 { + 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, 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 { + // 🔴 建表选项来自**表单**(基线平台同款:`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 { + 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, 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(), "非法标识符必须给出修复指引"); + } +} diff --git a/src/backend/src/lowcode_seed.rs b/src/backend/src/lowcode_seed.rs new file mode 100644 index 0000000..ee987d3 --- /dev/null +++ b/src/backend/src/lowcode_seed.rs @@ -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, + /// 已存在因而跳过的表。 + pub skipped: Vec, + /// 实际执行的 DDL。 + pub ddl: Vec, + /// 回写后的模型(`f_tables_data` 的新值)。 + pub model: Value, + /// 诊断信息。 + pub notes: Vec, + /// 是否只是演练(没建表、没写库)。 + 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 { + 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 { + let (form, model) = load_demo_fixture(project_dir)?; + let ddl = lowcode_ddl::preview_ddl(&model, &form)?; + + let planned: Vec = 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 { + 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 { + 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 = 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 = Vec::new(); + let mut assignments: Vec = 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()); + } +} diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index a1cb73c..e9b75f5 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -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 { + #[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() { diff --git a/src/backend/src/mcp_adapter.rs b/src/backend/src/mcp_adapter.rs index 207f1de..73f69db 100644 --- a/src/backend/src/mcp_adapter.rs +++ b/src/backend/src/mcp_adapter.rs @@ -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 { + 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 = 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 { + 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 { + 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 { + 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}"), diff --git a/src/backend/tests/lowcode_crud_it.rs b/src/backend/tests/lowcode_crud_it.rs new file mode 100644 index 0000000..51240dc --- /dev/null +++ b/src/backend/tests/lowcode_crud_it.rs @@ -0,0 +1,1131 @@ +//! lowcode_crud 集成测试 —— **真实 pglite 库**上的动态 CRUD 闭环。 +//! +//! ## 为什么必须是真库 +//! +//! `sspf-lowcode` 的单测证明的是「SQL 文本长得对」。 +//! 但真正的坑都在**执行**这一侧: +//! +//! | 坑 | 只有真库能暴露 | +//! |---|---| +//! | 参数没加 cast | `cannot convert between the Rust type String and the Postgres type timestamp` | +//! | 列名与真实表对不上 | `column "f_xxx" does not exist` | +//! | 占位符个数对不上 | `bind message supplies 3 parameters, but prepared statement requires 2` | +//! | 事务没回滚 | 主表失败后子表留孤儿行 | +//! +//! 这四条在 SQL 文本层面**全都看不出来**。 +//! +//! ## 🔴 pglite 是进程级单例 +//! +//! 第二个 `open_temp()` ⇒ `AlreadyOpen` ⇒ 全文件共用一个库(`OnceCell`), +//! 并用一把进程级 `Mutex` 把测试**整体串行**(Rust test harness 默认并发跑同文件的 +//! `#[tokio::test]` ⇒ 共用库会互相踩数据)。 +//! +//! ## 🔴 每个测试用**自己专属**的表名 +//! +//! 不依赖测试执行顺序 —— 断言「不存在」之前自己造前置条件。 + +use serde_json::json; +use ssw_platform::lowcode_crud::{ + build_context, delete_record, insert_record, now_iso, update_record, DEFAULT_TENANT_ID, +}; +use ssw_platform::platform::db::Db; +use sspf_lowcode::{FormSchema, ModelSchema}; +use tokio::sync::{Mutex, OnceCell}; + +/// 全文件共享的临时库。 +static DB: OnceCell = 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 +} + +// ============================================================ +// 动态表:按 JNPF 建表规则造 +// ============================================================ + +/// 建一张**主表**,列名形态照 JNPF 动态建表(`lower(vModel)`)。 +/// +/// 🔴 系统列的名字**从模型推导**,所以这里必须**逐字匹配**模型里推出来的名字: +/// - `F_Id` → `f_id` +/// - `F_CreatorTime` → `f_creatortime`(**无下划线**) +/// - `f_tenant_id` → `f_tenant_id`(平台常量,**有下划线**) +async fn create_main_table(db: &Db, table: &str) { + db.exec(&format!( + "CREATE TABLE {table} ( + f_id VARCHAR(50) NOT NULL, + f_room VARCHAR(100), + f_company_name VARCHAR(100), + f_amount NUMERIC(18,2), + 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_flow_task_id VARCHAR(50), + PRIMARY KEY (f_id) + )" + )) + .await + .expect("建主表失败"); +} + +/// 建一张**子表**(外键列照模型的 `tableField` → `f_receivableid`)。 +async fn create_sub_table(db: &Db, table: &str) { + db.exec(&format!( + "CREATE TABLE {table} ( + f_id VARCHAR(50) NOT NULL, + f_receivableid VARCHAR(50), + f_month VARCHAR(20), + f_rent NUMERIC(18,2), + f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id) + )" + )) + .await + .expect("建子表失败"); +} + +// ============================================================ +// 表单 / 模型(合成,但列名形态照官方 fixture) +// ============================================================ + +/// 表单:主表字段 + 一个子表。 +fn form_json(main: &str, sub: &str) -> String { + json!({ + "formRef": "formRef", + "formModel": "formData", + "fields": [ + { + "__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__": "F_Amount", + "__config__": { + "jnpfKey": "inputNumber", "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" + } + } + ] + } + ] + }) + .to_string() +} + +/// 模型:主表 + 子表(`tableField` / `relationField` 照 JNPF 语义)。 +fn model_json(main: &str, sub: &str) -> String { + json!([ + { + "table": main, + "tableName": "主表", + "typeId": "1", + "fields": [ + { "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "F_Room", "columnName": null, "dataType": "varchar" }, + { "field": "F_Company_name", "columnName": null, "dataType": "varchar" }, + { "field": "F_Amount", "columnName": null, "dataType": "decimal" }, + { "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" }, + { "field": "F_CreatorUserId", "columnName": null, "dataType": "varchar" }, + { "field": "F_LastModifyTime", "columnName": null, "dataType": "datetime" }, + { "field": "F_LastModifyUserId", "columnName": null, "dataType": "varchar" }, + { "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "f_flow_task_id", "columnName": null, "dataType": "varchar" } + ] + }, + { + "table": sub, + "tableName": "子表", + "typeId": "0", + "tableField": "F_Receivableid", + "relationField": "F_Id", + "fields": [ + { "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "F_Receivableid", "columnName": null, "dataType": "varchar" }, + { "field": "F_Month", "columnName": null, "dataType": "varchar" }, + { "field": "F_Rent", "columnName": null, "dataType": "decimal" }, + { "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" }, + { "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 } + ] + } + ]) + .to_string() +} + +fn parse_form(s: &str) -> FormSchema { + FormSchema::parse(&serde_json::from_str(s).expect("表单 JSON 非法")).expect("表单应可解析") +} + +fn parse_model(s: &str) -> ModelSchema { + ModelSchema::parse(&serde_json::from_str(s).expect("模型 JSON 非法")).expect("模型应可解析") +} + +/// 单租户上下文(租户值恒为 `"0"`)。 +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 +} + +// ============================================================ +// ① 新增:主表 + 子表,值真的落库 +// ============================================================ + +#[tokio::test] +async fn insert_writes_main_and_sub_rows() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_a").await; + create_sub_table(db, "it_sub_a").await; + + let form = parse_form(&form_json("it_main_a", "it_sub_a")); + let model = parse_model(&model_json("it_main_a", "it_sub_a")); + + let payload = json!({ + "F_Room": "A-101", + "F_Company_name": "某某公司", + "F_Amount": 1234.56, + "tableField1": [ + { "F_Month": "2026-10", "F_Rent": 100.5 }, + { "F_Month": "2026-11", "F_Rent": 200.25 } + ] + }); + + let mut c = ctx(); + let out = insert_record(db, &form, &model, &payload, &mut c, false) + .await + .expect("新增应成功"); + assert!(!out.dry_run); + assert_eq!(out.statements, 3, "1 主表 + 2 子表 = 3 条: {out:?}"); + + // 主表行确实在库里 + let rows = db + .query_json_params( + "SELECT f_id AS \"id\", f_room AS \"room\", f_amount AS \"amount\", \ + f_tenant_id AS \"tenant\" FROM it_main_a 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]["amount"], json!(1234.56)); + + // 🔴 单租户口径:租户列必须**被写**成 "0"(Java `addTenantId()` 无条件执行) + assert_eq!( + rows[0]["tenant"], + json!(DEFAULT_TENANT_ID), + "🔴 单租户下 f_tenant_id 应写 \"0\"(不是 NULL)" + ); + + // 子表行确实在库里,且外键指向主表主键 + let subs = db + .query_json_params( + "SELECT f_month AS \"month\", f_rent AS \"rent\", f_receivableid AS \"fk\" \ + FROM it_sub_a 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()), "子表外键应指向主表主键"); +} + +/// 🔴 数值列必须真的存成数值 —— 参数没 cast 就会报类型错。 +#[tokio::test] +async fn numeric_columns_survive_real_roundtrip() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_num").await; + + let form = parse_form(&form_json("it_main_num", "it_sub_num")); + let model = parse_model(&model_json("it_main_num", "it_sub_num")); + + let mut c = ctx(); + let out = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "B-202", "F_Amount": 0.01 }), + &mut c, + false, + ) + .await + .expect("新增应成功"); + + let rows = db + .query_json_params( + "SELECT f_amount AS \"amount\" FROM it_main_num WHERE f_id = $1", + &[&out.id], + ) + .await + .expect("查主表失败"); + assert_eq!(rows.len(), 1); + assert_eq!( + rows[0]["amount"], + json!(0.01), + "🔴 数值列应原样落库(没被转成文本或丢精度)" + ); +} + +// ============================================================ +// ② dry-run:生成 SQL 但**不落库** +// ============================================================ + +#[tokio::test] +async fn dry_run_does_not_write_anything() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_dry").await; + + let form = parse_form(&form_json("it_main_dry", "it_sub_dry")); + let model = parse_model(&model_json("it_main_dry", "it_sub_dry")); + + let mut c = ctx(); + let out = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "C-303" }), + &mut c, + true, + ) + .await + .expect("dry-run 应成功"); + + assert!(out.dry_run, "应标记为 dry-run"); + assert!(out.statements > 0, "应生成 SQL"); + + let rows = db + .query_json("SELECT f_id FROM it_main_dry") + .await + .expect("查主表失败"); + assert!( + rows.is_empty(), + "🔴 dry-run 不该落库,但查到了 {} 行", + rows.len() + ); +} + +// ============================================================ +// ③ 更新:子表差集对账(改一行 / 加一行 / 删一行) +// ============================================================ + +#[tokio::test] +async fn update_reconciles_sub_table_diff() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_u").await; + create_sub_table(db, "it_sub_u").await; + + let form = parse_form(&form_json("it_main_u", "it_sub_u")); + let model = parse_model(&model_json("it_main_u", "it_sub_u")); + + // 先新增 2 行 + let mut c = ctx(); + let out = insert_record( + db, + &form, + &model, + &json!({ + "F_Room": "D-404", + "tableField1": [ + { "F_Month": "2026-10", "F_Rent": 100 }, + { "F_Month": "2026-11", "F_Rent": 200 } + ] + }), + &mut c, + false, + ) + .await + .expect("新增应成功"); + + // 取旧的两行主键 + let old = db + .query_json_params( + "SELECT f_id AS \"id\", f_month AS \"month\" FROM it_sub_u \ + WHERE f_receivableid = $1 ORDER BY f_month", + &[&out.id], + ) + .await + .expect("查子表失败"); + assert_eq!(old.len(), 2); + let keep_id = old[0]["id"].as_str().unwrap().to_string(); // 2026-10 保留 + let drop_id = old[1]["id"].as_str().unwrap().to_string(); // 2026-11 删掉 + + // 更新:保留第 1 行(改租金)、删掉第 2 行、加第 3 行 + let mut c2 = ctx(); + let up = update_record( + db, + &form, + &model, + &json!({ + "F_Room": "D-405", + "tableField1": [ + { "f_id": keep_id, "F_Month": "2026-10", "F_Rent": 150 }, + { "F_Month": "2026-12", "F_Rent": 300 } + ] + }), + &mut c2, + &out.id, + false, + ) + .await + .expect("更新应成功"); + + // 主表改了 + let main = db + .query_json_params( + "SELECT f_room AS \"room\" FROM it_main_u WHERE f_id = $1", + &[&out.id], + ) + .await + .expect("查主表失败"); + assert_eq!(main[0]["room"], json!("D-405"), "主表应被更新"); + + // 子表差集:留 1 行、删 1 行、加 1 行 ⇒ 共 2 行 + let after = db + .query_json_params( + "SELECT f_month AS \"month\", f_rent AS \"rent\" FROM it_sub_u \ + WHERE f_receivableid = $1 ORDER BY f_month", + &[&out.id], + ) + .await + .expect("查子表失败"); + assert_eq!( + after.len(), + 2, + "🔴 差集对账后应剩 2 行(留 1 加 1 删 1): {after:?}" + ); + assert_eq!(after[0]["month"], json!("2026-10")); + assert_eq!(after[0]["rent"], json!(150.0), "保留的行应被更新"); + assert_eq!(after[1]["month"], json!("2026-12"), "新增的行应在"); + + // 被删的行确实没了 + let gone = db + .query_json_params( + "SELECT f_id FROM it_sub_u WHERE f_id = $1", + &[&drop_id], + ) + .await + .expect("查子表失败"); + assert!(gone.is_empty(), "🔴 缺失的旧行应被删除(物理删)"); + let _ = up; +} + +// ============================================================ +// ④ 删除:主表 + 子表 +// ============================================================ + +#[tokio::test] +async fn delete_removes_main_and_sub_rows() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_d").await; + create_sub_table(db, "it_sub_d").await; + + let form = parse_form(&form_json("it_main_d", "it_sub_d")); + let model = parse_model(&model_json("it_main_d", "it_sub_d")); + + 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 main = db + .query_json_params("SELECT f_id FROM it_main_d WHERE f_id = $1", &[&out.id]) + .await + .expect("查主表失败"); + assert!(main.is_empty(), "🔴 主表行应被删除"); + + let subs = db + .query_json_params( + "SELECT f_id FROM it_sub_d WHERE f_receivableid = $1", + &[&out.id], + ) + .await + .expect("查子表失败"); + assert!(subs.is_empty(), "🔴 子表行应被删除(不能留孤儿)"); +} + +// ============================================================ +// ⑤ 列不一致:设计稿有、真实库没有 ⇒ 拒绝写 +// ============================================================ + +#[tokio::test] +async fn column_mismatch_is_rejected_before_writing() { + let _g = LOCK.lock().await; + let db = db().await; + // 故意少建一列:f_company_name + db.exec( + "CREATE TABLE it_main_m ( + f_id VARCHAR(50) NOT NULL, + f_room VARCHAR(100), + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id) + )", + ) + .await + .expect("建表失败"); + + let form = parse_form(&form_json("it_main_m", "it_sub_m")); + let model = parse_model(&model_json("it_main_m", "it_sub_m")); + + let mut c = ctx(); + let err = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "F-606" }), + &mut c, + false, + ) + .await + .expect_err("🔴 真实库缺列时必须拒绝写"); + + assert_eq!( + err.code, + "COLUMN_MISMATCH", + "应报列不一致: {}", + err.message + ); + + // 🔴 拒绝 ⇒ 一行都不能写进去 + let rows = db + .query_json("SELECT f_id FROM it_main_m") + .await + .expect("查主表失败"); + assert!( + rows.is_empty(), + "🔴 拒绝写入后表里不该有数据,但有 {} 行", + rows.len() + ); +} + +// ============================================================ +// ⑥ 事务回滚:中途失败不留孤儿行 +// ============================================================ + +#[tokio::test] +async fn failure_leaves_no_orphan_rows() { + let _g = LOCK.lock().await; + let db = db().await; + // 主表有 f_room,子表**没有** f_rent ⇒ 子表 INSERT 会失败 + db.exec( + "CREATE TABLE it_main_t ( + f_id VARCHAR(50) NOT NULL, + f_room VARCHAR(100), + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id) + )", + ) + .await + .expect("建主表失败"); + db.exec( + "CREATE TABLE it_sub_t ( + f_id VARCHAR(50) NOT NULL, + f_receivableid VARCHAR(50), + f_month VARCHAR(20), + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id) + )", + ) + .await + .expect("建子表失败"); + + let form = parse_form(&form_json("it_main_t", "it_sub_t")); + let model = parse_model(&model_json("it_main_t", "it_sub_t")); + + let mut c = ctx(); + let err = insert_record( + db, + &form, + &model, + &json!({ + "F_Room": "G-707", + "tableField1": [ { "F_Month": "2026-10", "F_Rent": 100 } ] + }), + &mut c, + false, + ) + .await + .expect_err("子表缺列时应失败"); + + // 两种可能:列校验阶段就拦下(COLUMN_MISMATCH), + // 或者执行阶段炸了(DB_ERROR)—— 都算「拒绝了这次写入」。 + assert!( + err.code == "COLUMN_MISMATCH" || err.code == "DB_ERROR", + "应报结构化错误,实际: {} / {}", + err.code, + err.message + ); + + // 🔴 关键:主表也不能留下行(一个事务,要么全成要么全不成) + let main = db + .query_json("SELECT f_id FROM it_main_t") + .await + .expect("查主表失败"); + assert!( + main.is_empty(), + "🔴 事务回滚后主表不该有孤儿行,但有 {} 行: {main:?}", + main.len() + ); + let subs = db + .query_json("SELECT f_id FROM it_sub_t") + .await + .expect("查子表失败"); + assert!( + subs.is_empty(), + "🔴 事务回滚后子表不该有孤儿行,但有 {} 行: {subs:?}", + subs.len() + ); +} + +// ============================================================ +// ⑦ 表不存在 +// ============================================================ + +#[tokio::test] +async fn missing_table_is_reported_clearly() { + let _g = LOCK.lock().await; + let db = db().await; + + let form = parse_form(&form_json("it_missing_main", "it_missing_sub")); + let model = parse_model(&model_json("it_missing_main", "it_missing_sub")); + + let mut c = ctx(); + let err = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "H-808" }), + &mut c, + false, + ) + .await + .expect_err("表不存在时应报错"); + + assert_eq!( + err.code, + "TABLE_NOT_IN_DB", + "应报表不存在: {}", + err.message + ); +} + +// ============================================================ +// ⑧ 更新不存在的记录 +// ============================================================ + +#[tokio::test] +async fn update_of_missing_record_is_rejected() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_nu").await; + + let form = parse_form(&form_json("it_main_nu", "it_sub_nu")); + let model = parse_model(&model_json("it_main_nu", "it_sub_nu")); + + let mut c = ctx(); + let err = update_record( + db, + &form, + &model, + &json!({ "F_Room": "I-909" }), + &mut c, + "no-such-id", + false, + ) + .await + .expect_err("更新不存在的记录应报错"); + + assert!( + err.code.starts_with("RECORD") || err.code == "NOT_FOUND", + "应报记录不存在,实际: {} / {}", + err.code, + err.message + ); +} + +// ============================================================ +// ⑨ 唯一性校验:重复值必须被拦下(且一条都不能写进去) +// ============================================================ + +/// 🔴 带唯一性的表单(`F_Room` 标了 `unique`,`F_Code` 是业务主键)。 +fn unique_form_json(main: &str) -> String { + json!({ + "formRef": "formRef", + "formModel": "formData", + "logicalDelete": true, + "useBusinessKey": true, + "businessKeyList": ["F_Code"], + "businessKeyTip": "业务编码已存在", + "fields": [ + { + "__vModel__": "F_Room", + "__config__": { + "jnpfKey": "input", "label": "房间号", "layout": "colFormItem", + "tableName": main, "required": true, "unique": true + } + }, + { + "__vModel__": "F_Code", + "__config__": { + "jnpfKey": "input", "label": "业务编码", "layout": "colFormItem", + "tableName": main, "required": true + } + } + ] + }) + .to_string() +} + +/// 模型:主表 + 唯一字段 + 业务主键字段 + 删除标记。 +fn unique_model_json(main: &str) -> String { + json!([ + { + "table": main, "tableName": "主表", "typeId": "1", + "fields": [ + { "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "F_Room", "columnName": null, "dataType": "varchar" }, + { "field": "F_Code", "columnName": null, "dataType": "varchar" }, + { "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" }, + { "field": "F_CreatorUserId", "columnName": null, "dataType": "varchar" }, + { "field": "F_LastModifyTime", "columnName": null, "dataType": "datetime" }, + { "field": "F_LastModifyUserId", "columnName": null, "dataType": "varchar" }, + { "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }, + { "field": "f_flow_task_id", "columnName": null, "dataType": "varchar" }, + { "field": "F_Delete_Mark", "columnName": null, "dataType": "int4" } + ] + } + ]) + .to_string() +} + +/// 主表(带删除标记列 —— 逻辑删除的行不参与判重)。 +async fn create_main_table_with_delete_mark(db: &Db, table: &str) { + db.exec(&format!( + "CREATE TABLE {table} ( + f_id VARCHAR(50) NOT NULL, + f_room VARCHAR(100), + f_code VARCHAR(100), + 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_flow_task_id VARCHAR(50), + f_delete_mark INTEGER, + PRIMARY KEY (f_id) + )" + )) + .await + .expect("建主表失败"); +} + +/// 🔴 唯一字段重复 ⇒ 必须拒绝,且**一条都不能写进去**。 +#[tokio::test] +async fn duplicate_unique_value_is_rejected() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table_with_delete_mark(db, "it_main_uniq").await; + + let form = parse_form(&unique_form_json("it_main_uniq")); + let model = parse_model(&unique_model_json("it_main_uniq")); + + // 第一条:房间号 X-1 + let mut c = ctx(); + insert_record( + db, + &form, + &model, + &json!({ "F_Room": "X-1", "F_Code": "CODE-1" }), + &mut c, + false, + ) + .await + .expect("第一条应成功"); + + // 第二条:房间号一样 ⇒ 唯一冲突 + let mut c2 = ctx(); + let err = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "X-1", "F_Code": "CODE-2" }), + &mut c2, + false, + ) + .await + .expect_err("🔴 重复的唯一值必须被拒绝"); + + assert_eq!( + err.code, "UNIQUE_CONSTRAINT_VIOLATED", + "应报唯一性冲突: {}", + err.message + ); + + // 🔴 拒绝 ⇒ 库里还是只有 1 行 + let rows = db + .query_json("SELECT f_id, f_room FROM it_main_uniq") + .await + .expect("查主表失败"); + assert_eq!( + rows.len(), + 1, + "🔴 被拒的写入不该进库,但有 {} 行: {rows:?}", + rows.len() + ); +} + +/// 🔴 更新时改别的字段,**不能**被自己的唯一值判成冲突(要排除自己)。 +#[tokio::test] +async fn update_excludes_itself_from_unique_check() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table_with_delete_mark(db, "it_main_uniq2").await; + + let form = parse_form(&unique_form_json("it_main_uniq2")); + let model = parse_model(&unique_model_json("it_main_uniq2")); + + let mut c = ctx(); + let out = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "Y-1", "F_Code": "CODE-Y" }), + &mut c, + false, + ) + .await + .expect("新增应成功"); + + // 只改业务编码,唯一字段(房间号)原样带回去 ⇒ 不该冲突 + let mut c2 = ctx(); + update_record( + db, + &form, + &model, + &json!({ "F_Room": "Y-1", "F_Code": "CODE-Y2" }), + &mut c2, + &out.id, + false, + ) + .await + .expect("🔴 更新自己不该被判唯一冲突"); + + // 但改成别人的房间号 ⇒ 冲突 + db.exec("INSERT INTO it_main_uniq2 (f_id, f_room, f_code) VALUES ('other', 'Y-2', 'CODE-Z')") + .await + .expect("插入对照行失败"); + + let mut c3 = ctx(); + let err = update_record( + db, + &form, + &model, + &json!({ "F_Room": "Y-2", "F_Code": "CODE-Y3" }), + &mut c3, + &out.id, + false, + ) + .await + .expect_err("🔴 改成别人已占的room号必须被拒绝"); + + assert_eq!(err.code, "UNIQUE_CONSTRAINT_VIOLATED"); +} + +/// 🔴 业务主键(组合)重复 ⇒ 必须被拒绝。 +#[tokio::test] +async fn duplicate_business_key_is_rejected() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table_with_delete_mark(db, "it_main_bk").await; + + // 🔴 业务主键字段 F_Code 不是 unique 字段 ⇒ 唯一校验不会拦它, + // 必须由业务主键校验单独拦。 + let form = parse_form(&unique_form_json("it_main_bk")); + let model = parse_model(&unique_model_json("it_main_bk")); + + let mut c = ctx(); + insert_record( + db, + &form, + &model, + &json!({ "F_Room": "Z-1", "F_Code": "BK-1" }), + &mut c, + false, + ) + .await + .expect("第一条应成功"); + + let mut c2 = ctx(); + let err = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "Z-2", "F_Code": "BK-1" }), + &mut c2, + false, + ) + .await + .expect_err("🔴 重复的业务主键必须被拒绝"); + + assert_eq!( + err.code, "BUSINESS_KEY_VIOLATED", + "应报业务主键冲突: {}", + err.message + ); + assert!( + err.message.contains("业务编码已存在"), + "🔴 应使用设计稿里的 businessKeyTip 文案: {}", + err.message + ); + + let rows = db + .query_json("SELECT f_id FROM it_main_bk") + .await + .expect("查主表失败"); + assert_eq!(rows.len(), 1, "🔴 被拒的写入不该进库"); +} + +/// 🔴 **dry-run 也要做业务校验** —— dry-run 的意义是「先看会不会被拦」。 +#[tokio::test] +async fn dry_run_also_reports_unique_conflict() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table_with_delete_mark(db, "it_main_uniq3").await; + + let form = parse_form(&unique_form_json("it_main_uniq3")); + let model = parse_model(&unique_model_json("it_main_uniq3")); + + let mut c = ctx(); + insert_record( + db, + &form, + &model, + &json!({ "F_Room": "W-1", "F_Code": "CODE-W" }), + &mut c, + false, + ) + .await + .expect("第一条应成功"); + + let mut c2 = ctx(); + let err = insert_record( + db, + &form, + &model, + &json!({ "F_Room": "W-1", "F_Code": "CODE-W2" }), + &mut c2, + true, + ) + .await + .expect_err("🔴 dry-run 也必须报唯一冲突(否则 AI 会以为能落库)"); + + assert_eq!(err.code, "UNIQUE_CONSTRAINT_VIOLATED"); +} + +// ============================================================ +// ⑩ only_update:只更新不删除(基线的 Excel 导入 / 流程场景) +// ============================================================ + +/// 🔴 `only_update = true` ⇒ 入参里缺失的旧行**不删**。 +/// +/// 基线平台 `FlowFormDataUtil.updateTable()`: +/// ```java +/// if (CollUtil.isNotEmpty(deleteList) && !onlyUpdate) { /* 删缺失的旧行 */ } +/// ``` +#[tokio::test] +async fn only_update_keeps_missing_old_rows() { + let _g = LOCK.lock().await; + let db = db().await; + create_main_table(db, "it_main_ou").await; + create_sub_table(db, "it_sub_ou").await; + + let form = parse_form(&form_json("it_main_ou", "it_sub_ou")); + let model = parse_model(&model_json("it_main_ou", "it_sub_ou")); + + let mut c = ctx(); + let out = insert_record( + db, + &form, + &model, + &json!({ + "F_Room": "OU-1", + "tableField1": [ + { "F_Month": "2026-10", "F_Rent": 100 }, + { "F_Month": "2026-11", "F_Rent": 200 } + ] + }), + &mut c, + false, + ) + .await + .expect("新增应成功"); + + let old = db + .query_json_params( + "SELECT f_id AS \"id\", f_month AS \"month\" FROM it_sub_ou \ + WHERE f_receivableid = $1 ORDER BY f_month", + &[&out.id], + ) + .await + .expect("查子表失败"); + assert_eq!(old.len(), 2); + let keep_id = old[0]["id"].as_str().unwrap().to_string(); + + // 只传 1 行 ⇒ 默认(only_update=false)会删掉另一行 + let mut c2 = ctx(); + update_record( + db, + &form, + &model, + &json!({ + "F_Room": "OU-1", + "tableField1": [ { "f_id": keep_id, "F_Month": "2026-10", "F_Rent": 150 } ] + }), + &mut c2, + &out.id, + false, + ) + .await + .expect("更新应成功"); + + let after_default = db + .query_json_params( + "SELECT f_month AS \"month\" FROM it_sub_ou WHERE f_receivableid = $1 ORDER BY f_month", + &[&out.id], + ) + .await + .expect("查子表失败"); + assert_eq!( + after_default.len(), + 1, + "🔴 默认行为(only_update=false)应删掉缺失的旧行: {after_default:?}" + ); + + // 再造一条数据,用 only_update=true 更新 ⇒ 旧行应保留 + let mut c3 = ctx(); + let out2 = insert_record( + db, + &form, + &model, + &json!({ + "F_Room": "OU-2", + "tableField1": [ + { "F_Month": "2026-10", "F_Rent": 100 }, + { "F_Month": "2026-11", "F_Rent": 200 } + ] + }), + &mut c3, + false, + ) + .await + .expect("新增应成功"); + + let old2 = db + .query_json_params( + "SELECT f_id AS \"id\", f_month AS \"month\" FROM it_sub_ou \ + WHERE f_receivableid = $1 ORDER BY f_month", + &[&out2.id], + ) + .await + .expect("查子表失败"); + let keep2 = old2[0]["id"].as_str().unwrap().to_string(); + + let mut c4 = ctx(); + ssw_platform::lowcode_crud::update_record_with( + db, + &form, + &model, + &json!({ + "F_Room": "OU-2", + "tableField1": [ { "f_id": keep2, "F_Month": "2026-10", "F_Rent": 180 } ] + }), + &mut c4, + &out2.id, + false, + true, + ) + .await + .expect("only_update 更新应成功"); + + let after_only = db + .query_json_params( + "SELECT f_month AS \"month\", f_rent AS \"rent\" FROM it_sub_ou \ + WHERE f_receivableid = $1 ORDER BY f_month", + &[&out2.id], + ) + .await + .expect("查子表失败"); + assert_eq!( + after_only.len(), + 2, + "🔴 only_update=true 时缺失的旧行应保留: {after_only:?}" + ); + assert_eq!(after_only[0]["rent"], json!(180.0), "传进来的那行应被更新"); + assert_eq!(after_only[1]["month"], json!("2026-11"), "没传的旧行应原样保留"); +} + + diff --git a/src/backend/tests/lowcode_ddl_it.rs b/src/backend/tests/lowcode_ddl_it.rs new file mode 100644 index 0000000..fc4058b --- /dev/null +++ b/src/backend/tests/lowcode_ddl_it.rs @@ -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 = 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 = 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 = 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 = 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("🔴 已逻辑删除的行不该再占着唯一值"); +} diff --git a/src/backend/tests/lowcode_ddl_kernel_it.rs b/src/backend/tests/lowcode_ddl_kernel_it.rs new file mode 100644 index 0000000..4d85250 --- /dev/null +++ b/src/backend/tests/lowcode_ddl_kernel_it.rs @@ -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 = 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")); +} diff --git a/src/backend/tests/lowcode_seed_it.rs b/src/backend/tests/lowcode_seed_it.rs new file mode 100644 index 0000000..490f495 --- /dev/null +++ b/src/backend/tests/lowcode_seed_it.rs @@ -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 = 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::>(), + "🔴 建出来的列必须与官方真实 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()); + } +}