feat(face-b): 数据建模写面落地(面 B 批次 7,+8 端点,真 DDL)

- 建表/改表/加字段/删表/清空/复制/导出/导入 八条,均过 db_ident 白名单
- 内置表护栏取 DDL 真源:schema.sql 里 35 张全部只给看(禁改禁删)
- 官方 checkTab 双闸照抄:系统自带表 DB101/DB102、表里有数据 DB201/DB202
- update 是重建表 ⇒ 用 DROP+CREATE 同一批给 exec(隐式事务,无中间态)
- addFields 不要求主键、只 ADD COLUMN IF NOT EXISTS、新列一律可空
- Copy 用 LIKE … INCLUDING ALL(保主键/自增);带数据走显式列清单避开 MEM1
- 修 db_field_rows 的 decimal 长度:18 → 18,4(否则编辑一次表就丢小数位)
- deleteAllTable 有意收窄:只删非内置表(官方全删含系统表 = 拆平台)
- Export/Import 恒 400 + 人话,不返假下载地址
- 回归 tests/batch7_it.rs(8 条);cargo test --workspace 521 passed
This commit is contained in:
admin committed 2026-11-01 09:03:21 +08:00
1 parent 6ed89a33ca
commit 6f8dcaa58a
8 files changed
+1657 -23

No files matched your search

+46
View File
@@ -83,3 +83,49 @@
数据建模**写面** 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`)。
动真 DDL 前先立两条护栏:① `base_*` 平台表禁止 ALTER/DROP(只允许看);
② 表名/列名一律过 `db_ident` 白名单再拼 SQL。
---
## 批次 7 —— 数据建模**写面**(真 DDL),2026-11-01
**8 条面 B 端点**:`POST/PUT /DataModel/{linkId}/Table`(建表 / 改表)+ `PUT …/addFields`
+ `DELETE …/Table/{tableName}` + `DELETE …/deleteAllTable` + `POST …/Table/{t}/Actions/Copy`
+ `GET …/Actions/Export` + `POST …/Actions/Import`。无新表(只动真表结构)。
### 两条护栏(缺一不可,别再想别的方案)
1. `db_ident` 白名单 —— 全仓**唯一**能把字符串拼进 DDL 的入口(`[A-Za-z_][A-Za-z0-9_]*` + 双引号)。
2. `is_builtin_table(t)` = `sspf_store::db::ddl_tables()` —— `schema.sql` 里定义过的 **35 张只给看**。
🔴 判据必须**取 DDL 真源**:在 handler 里另抄一份清单 = 「加了表忘了加护栏」,
新表能被用户从建模页一键删掉。
官方 `checkTab` 两道闸照抄:内置表 `DB101/DB102`、**表里有数据** `DB201/DB202`。
### 踩到 / 想清楚的 6 个点
- 🔴 **`update` 是重建表**(官方 `creTable`→`dropTable`→`reTableName`)⇒「有数据就拒」
这条闸**不能省**,省了就是「改个表注释,数据全没」。本仓写 `DROP; CREATE …` **同一批**
给 `Db::exec`(simple protocol ⇒ 隐式事务)⇒ 比官方少一个「删了旧表但新表没建起来」的中间态。
- 🔴 **`addFields` 不能要求主键**:主键早在表上,要求了就是「加一列」永远 400。
这是实测踩到的(第一版照抄 create 的 `parse_db_fields`)。
⇒ 加 `require_pk: bool` 参数,create/update 传 true、addFields 传 false。
- 🔴 **`dataLength` 对 `decimal` 必须带小数位**(`18,4`):只给精度 `18` 的话,
前端编辑一次表就把 `numeric(18,4)` 改成 `numeric(18,0)`,**静默丢精度**。
改 `db_field_rows` 的 `numeric_precision || ',' || numeric_scale`。
- 🔴 **`Copy` 用 `LIKE … INCLUDING ALL`**(官方按字段清单重建会**丢自增**);
`type=1` 的数据搬运写**显式列清单** —— `INSERT … SELECT *` 会被 `check-arch` 的 MEM1 判红。
- 🔴 **`deleteAllTable` 有意收窄**:官方删全部表(含系统表)⇒ 在这仓等于把平台拆了
(`base_user` 一没就登不回来,种子只在空库跑)⇒ 只删「不在 `schema.sql` 里」的表。
- **建表要先查重名**:只靠 PG 会漏出 `42P07 relation already exists` 英文报错给用户看;
官方是 `isExistTable` ⇒ `EXIST001`「名称不能重复」。
### 数字(批次 7 收尾)
`cargo test --workspace` **521**(+8)| `fe-gap` **235/900 = 26.1%**(systemData **35/106 = 33.0%**)
| 契约端点 **273 条(面 B 243)** | 官方覆盖 **262/269(implemented 241 / partial 21 / absent 7)**
| 十二道闸门全绿 | 空载内存 7 MB
### 下一个(批次 8)
`systemData` 的 `Dataset`(16) / `DataInterface`(10) / `InterfaceOauth`(9) / `PortalManage`(4)
+ `system/printDev`(15)。`printDev` 是本仓没有打印服务 ⇒ 多半只能恒空 stub(先看页面再定)。
+2 -2
View File
@@ -222,7 +222,7 @@ ssw-platform/
每把尺子结尾比对「实际断言数 vs 契约登记数」,对不上即失败 —— 尺子不会被悄悄改弱。
**加任何业务模块 / 改任何契约 / 加任何 crate 依赖 / 改任何内部标识 / 加任何表,十二道闸门必须全绿才算完成。**
🔴 **`cargo test --workspace` 当前 502 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 52 + adapter-baseline 19 + lowcode 112 + 集成测试)——
🔴 **`cargo test --workspace` 当前 521 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 52 + adapter-baseline 19 + lowcode 112 + 集成测试)——
拆 crate 后总数会变,**不许把断言数写死**,跑一遍看实际值。
cipher 自证(免 node):`./target/release/ssw-platform --enc 123456`。
@@ -276,7 +276,7 @@ cp .env.example .env && ./run.sh install && ./run.sh dev
```bash
cargo build --release # 编译(workspace 根,含 crates/* 与 packs/*)
cargo test --workspace # 单测(当前 502 条)
cargo test --workspace # 单测(当前 521 条)
bash run.sh dev # 起后端(30010) + 前端(5173)
bash scripts/perm-smoke.sh # 面 A 43 条
bash scripts/perm-smoke-jnpf.sh # 面 B 23 条
+72 -17
View File
@@ -55,30 +55,48 @@
顺手把 `DictionaryData/All` 从「恒空」改成真读字典 + 灌 `businessType` 13 行种子。
详见 §1「批次 5」小节。
**下一个(批次 7)建议**:数据建模的**写面**(`POST/PUT/DELETE /DataModel/{linkId}/Table…`
~~**下一个(批次 7)建议**:数据建模的**写面**(`POST/PUT/DELETE /DataModel/{linkId}/Table…`
+ `addFields` + `Copy` + `Export`/`Import`,共 8 条)—— 这批要动**真 DDL**
(`CREATE TABLE` / `ALTER TABLE` / `DROP TABLE`),必须先立两条护栏:
① `base_*` 平台表**禁止** ALTER/DROP(只允许看);② 表名/列名一律过白名单再拼 SQL。
做完这三页(`/dataCenter/dataModel`、`/dataCenter/dataSource`、`/dataCenter/basicField`)
就真正可用了。再往后是 `systemData` 的 `Dataset`/`DataInterface`/`DataSource` 其余族。
① `base_*` 平台表**禁止** ALTER/DROP(只允许看);② 表名/列名一律过白名单再拼 SQL。~~
✅ **批次 7 做完(实际 8 条)**——两条护栏都立了,且**判据取 DDL 真源**:
**2026-11-01 实测**(`python3 scripts/fe-gap.py`):合计 **215 / 900**(23.9%);
`permission` 111/137(81.0%)、`system` **84/196(42.9%,批次 4 47→66、批次 5 66→84)**;
剩下体量最大的仍是 `workFlow`(104) / `onlineDev`(101) / `systemData`(91) / `aiCenter`(75) /
`extend`(64) / `msgCenter`(50) —— **基本都属于「本仓没这个模块」**。
- ① `db_ident` 白名单(`[A-Za-z_][A-Za-z0-9_]*` + 双引号包裹)—— 唯一能拼字符串进 DDL 的入口;
- ② `is_builtin_table` = `sspf_store::db::ddl_tables()` ⇒ **`schema.sql` 里定义过的 35 张全部只给看**
(不写死清单,加表自动受保护,不会「加了表忘了加护栏」)。
- 官方 `checkTab` 的两道闸照抄:内置表 `DB101/DB102`、**表里有数据** `DB201/DB202`。
- 🔴 `update` 是**重建表**(官方也是),所以「有数据就拒」这条闸**不能省** —— 省了就是「改个注释,数据全没」。
- 🔴 `addFields` **不要求主键**(主键早在表上):要求了会让「加一列」永远失败;
且只 `ADD COLUMN IF NOT EXISTS`,新列一律可空(给非空表加 `NOT NULL` 列必失败)。
- 🔴 `Copy` 用 `LIKE … INCLUDING ALL`(官方按字段清单重建会**丢自增**);
`type=1` 的数据搬运写成**显式列清单** —— `INSERT … SELECT *` 会被 `check-arch` MEM1 判成整表载入。
- `deleteAllTable` **有意收窄**:只删「不在 `schema.sql` 里」的表(官方全删,含系统表 ⇒ 在这仓等于自杀)。
- `Export`/`Import` 恒 `400` + 人话(没有文件服务 / 没启 multipart),**不返假下载地址**。
做完这三页(`/dataCenter/dataModel`、`/dataCenter/dataSource`、`/dataCenter/basicField`)
就真正可用了。再往后是 `systemData` 的 `Dataset`/`DataInterface` 其余族。
**2026-11-01 实测**(`python3 scripts/fe-gap.py`):合计 **235 / 900**(26.1%);
`permission` 111/137(81.0%)、`system` **84/196(42.9%,批次 4 47→66、批次 5 66→84)**、
**`systemData` 35/106(33.0%,批次 6 从 0 起、批次 7 29→35)**;
剩下体量最大的仍是 `workFlow`(104) / `onlineDev`(101) / `aiCenter`(75) /
`extend`(64) / `msgCenter`(50) / `systemData` 余下 71 —— **基本都属于「本仓没这个模块」**。
---
## 1. 一句话现状(2026-11-01 批次 6 收尾)
## 1. 一句话现状(2026-11-01 批次 7 收尾)
**📌 当前数字(以此为准,下面各批的「当时数字」仅存档)**:
- 契约端点 **265 条**(面 A 28 + 面 B **235** + 两面共用 2);`tables` → **35**。
- `cargo test --offline --workspace` = **513 passed / 0 failed**。
- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **254/261**
(implemented 236 / partial 18 / absent 7)。
- `python3 scripts/fe-gap.py`:合计 **229 / 900(25.4%)**,`permission` 111/137(81.0%)、
`system` 84/196(42.9%)、**`systemData` 29/106(27.4%,本批从 0 起)**。
- 契约端点 **273 条**(面 A 28 + 面 B **243** + 两面共用 2);`tables` → **35**。
- `cargo test --offline --workspace` = **521 passed / 0 failed**。
- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **262/269**
(implemented 241 / partial 21 / absent 7;oos 6 单列)。
- `python3 scripts/fe-gap.py`:合计 **235 / 900(26.1%)**,`permission` 111/137(81.0%)、
`system` 84/196(42.9%)、**`systemData` 35/106(33.0%)**。
- 🔴 **数据建模三页(`/dataCenter/dataModel` / `dataSource` / `basicField`)现在真能用了**:
建表 / 改表 / 加字段 / 删表 / 复制 / 预览 / 导出(明说不支持)全通,
平台表(`schema.sql` 里的 35 张)与「有数据的表」一律禁改禁删。
**✅ 后端已拆成 workspace 多 crate,业务包可独立编译;八道闸门全绿;空载内存 7 MB。**
@@ -246,6 +264,40 @@
两张字典的 7/10 行与 `dataTypeName` 联查、表清单分页/关键词/字段归一/`hasTableData`、
预览分页与单字段模糊、未登录 602。
### 批次 7(2026-11-01)—— 数据建模**写面**(真 DDL)
**8 条面 B 端点**:`POST/PUT /DataModel/{linkId}/Table`(建表 / 改表)
+ `PUT …/addFields`(加字段)+ `DELETE …/Table/{tableName}`(删表)
+ `DELETE …/deleteAllTable` + `POST …/Table/{t}/Actions/Copy` + `GET …/Actions/Export` + `POST …/Actions/Import`。
- 🔴 **两条护栏,缺一不可**:
① [`db_ident`] 白名单(`[A-Za-z_][A-Za-z0-9_]*` + 双引号)—— 全仓唯一能把字符串拼进 DDL 的入口;
② [`is_builtin_table`] = `sspf_store::db::ddl_tables()` ⇒ **`schema.sql` 里定义过的 35 张全部只给看**。
🔴 判据**取 DDL 真源**而不是在 handler 里再抄一份清单 —— 抄一份的后果是「加了表忘了加护栏」,
新表能被用户在建模页一键删掉。
- 🔴 **`update` 是重建表**(官方 `creTable`→`dropTable`→`reTableName`)⇒「表里有数据就拒」(`DB202`)
这条闸**不能省**:省了就是「改个表注释,数据全没」。本仓实现成
`DROP TABLE old; CREATE TABLE new …` **同一批**交给 `Db::exec`(simple protocol ⇒ 隐式事务),
比官方那三步少一个「删了旧表但新表没建起来」的中间态。
- 🔴 **`addFields` 不要求主键**:主键早在表上,还要求「必须选一个主键」会让**「加一列」永远失败**。
这条是实测踩到的(第一版照抄 create 的校验 ⇒ 400「请选择一个字段作为主键」)。
且只 `ADD COLUMN IF NOT EXISTS`、新列一律可空(给非空表加 `NOT NULL` 列必失败)。
- 🔴 **`Copy` 用 `CREATE TABLE … (LIKE … INCLUDING ALL)`**:主键 / `NOT NULL` / `DEFAULT` /
`IDENTITY` 一起带过去。官方是「读字段清单再重建」⇒ **复制出来的表丢自增**。
`type=1` 的数据搬运写**显式列清单**(`INSERT INTO dst (c1,c2) SELECT c1,c2 FROM src`)——
写 `SELECT *` 会被 `check-arch` 的 MEM1 判成「整表载入内存」。
- 🔴 **`deleteAllTable` 有意收窄**:官方删 `getTableList` 的**全部**表(含系统表,
在这仓等于把平台自己拆了 —— `base_user` 一没就再也登不回来,种子只在空库上跑)
⇒ 本仓只删「不在 `schema.sql` 里」的表,也就是用户自己从建模页建的。
- 🔴 **`dataLength` 对 `decimal` 必须带小数位**(`18,4` 而不是 `18`):只给精度的话,
前端编辑一次表就把 `numeric(18,4)` 改成 `numeric(18,0)`,**静默丢精度**。
改的是 `db_field_rows` 的 `numeric_precision || ',' || numeric_scale`。
- `Export`/`Import` 恒 `400` + 人话(没有文件服务 / 没启 `axum/multipart`),
**不返假下载地址**(前端会拿它去 `location.href`,得到一个 404 页面)。
- 回归测试 `tests/batch7_it.rs`(**8 条**):建表往返 + 重名、五类非法 schema、
内置表禁改禁删、改表重建 + 改名、加字段只追加、有数据的表冻结、
复制守卫 + 清空只删非内置、导出导入诚实失败。
### 🔴 上一批(第一批)踩到并解决的 4 个真 bug
1. `CurrentUser` 的 `preferenceJson` 必须是**字符串** `"{}"` —— 给对象会让前端
@@ -404,8 +456,11 @@ xop run --secret GU=git_local_user --secret GP=git_local_pass -- bash -c '
6. ~~`DataModel/{}/Tables`(12 页共用) + `DataSource` + `BasicDataType` + `CommonFields`~~
✅ **批次 6 做完(实际 16 条)**——新表 `base_db_link` / `base_data_type` / `base_common_fields`;
数据建模**只读面**(表清单/字段/预览)+ 数据连接 CRUD。**写面(真 DDL)留给批次 7**。
7. `DataModel` 写面 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`)
+ `systemData` 的 `Dataset`/`DataInterface`/`DataSource` 其余族 ⇒ **下一个**
7. ~~`DataModel` 写面 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`)~~
✅ **批次 7 做完(实际 8 条)**——真 DDL + 两道护栏(`db_ident` + `ddl_tables` 内置表清单)
+ 官方 `checkTab` 的「内置表 / 有数据」双闸。数据建模三页现在**真能用**。
8. `systemData` 的 `Dataset`(16) / `DataInterface`(10) / `InterfaceOauth`(9) / `PortalManage`(4)
其余族 + `system/printDev`(15) ⇒ **下一个**(`printDev` 是本仓没打印服务,多半只能恒空 stub)
**实现模板(照抄就行)**:`ORGANIZE_WRITE_FIELDS` / `POSITION_WRITE_FIELDS` 那一套
—— 列白名单 + `now()` 不占参数位 + 只 SET body 里出现的键 + 读回不选 `f_password`。
+1 -1
View File
@@ -251,7 +251,7 @@ ssw-platform/
| 能力 | 现状 | 目标 | 差距 |
|---|---|---|---|
| 面 B 契约端点 | ✅ 235 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) |
| 面 B 契约端点 | ✅ 243 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) |
| `base_*` DDL | ✅ 21 张逐字对齐 | 全量 331 张中的必需集 | 按域补 |
| 平台/业务分层 | ✅ `check-boundary.sh` 钉住 | 升级为 crate 级隔离 | **P0 已拆 contract / store / sdk;asset 包可独立编译;`jnpf.rs`→`face_b.rs`** |
| 低代码元数据引擎 | ✅ **P2-b 完成**:解析 + 校验 + 建表 + 动态 CRUD(6 个工具) | visualdev 同构 + 动态 CRUD + 发布 | 读 release / 单据号 / 乐观锁 → P2-c |
+18 -1
View File
@@ -1390,6 +1390,14 @@ B GET /api/system/DataModel/{linkId}/Table/{tableName} dataCenter.dataModel|onli
B GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields 登录 platform
B GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector 登录 platform
B GET /api/system/DataModel/{linkId}/Table/{tableName}/Preview dataCenter.dataModel platform
B POST /api/system/DataModel/{linkId}/Table dataCenter.dataModel platform
B PUT /api/system/DataModel/{linkId}/Table dataCenter.dataModel platform
B PUT /api/system/DataModel/{linkId}/addFields dataCenter.dataModel|onlineDev.formDesign platform
B DELETE /api/system/DataModel/{linkId}/Table/{tableName} dataCenter.dataModel platform
B DELETE /api/system/DataModel/{linkId}/deleteAllTable dataCenter.dataModel platform
B POST /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Copy dataCenter.dataModel platform
B GET /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Export dataCenter.dataModel platform
B POST /api/system/DataModel/{linkId}/Actions/Import dataCenter.dataModel platform
A GET /api/ssw/demo/DemoItem/List 登录 demo
A POST /api/ssw/demo/DemoItem/Save 登录 demo
A DELETE /api/ssw/demo/DemoItem/Delete 登录 demo
@@ -1406,7 +1414,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset
[FACE]
# face 条数 说明
A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条)
B 235 面 B 专属(官方 JNPF 形状)
B 243 面 B 专属(官方 JNPF 形状)
AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流)
[OFFICIAL]
@@ -1691,6 +1699,15 @@ GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector implemente
GET /api/system/DataModel/{linkId}/Table/{tableName} implemented DbTableController.java:251 面 B 已落地:`DbTableInfoVO`;`hasTableData` 用 `EXISTS` 真探测(判错会让前端在**有数据**的表上删列)
GET /api/system/DataModel/{linkId}/Table/{tableName}/Preview implemented DbTableController.java:168 面 B 已落地:逐列 `"col" AS "col"` 投影 —— **不能用 `SELECT *`**(`f_*` 会被归一成 camelCase,前端按原样列名取值 ⇒ 整表空白)
POST /api/system/DataModel/{linkId}/Table implemented DbTableController.java:271 面 B 已落地:真 `CREATE TABLE` + `COMMENT ON`;表名/列名过 `db_ident` 白名单,撞 `schema.sql` 里的表报「名称不能重复」(官方 `EXIST001`);自增/主键三条规矩照抄 `checkPrimary`
PUT /api/system/DataModel/{linkId}/Table implemented DbTableController.java:295 面 B 已落地:**重建表**(`DROP`+`CREATE` 同一批 ⇒ simple protocol 隐式事务,比官方的「临时表→删旧→改名」少一个中间态);内置表 `DB102`、有数据 `DB202`
PUT /api/system/DataModel/{linkId}/addFields implemented DbTableController.java:341 面 B 已落地:只 `ADD COLUMN IF NOT EXISTS`(**不删列、不要求主键**);新列一律可空 —— 给非空表加 `NOT NULL` 列必然失败
DELETE /api/system/DataModel/{linkId}/Table/{tableName} implemented DbTableController.java:361 面 B 已落地:内置表 `DB101`、有数据 `DB201`;`DROP TABLE`
DELETE /api/system/DataModel/{linkId}/deleteAllTable partial DbTableController.java:378 面 B 已落地但**有意收窄**:官方删 `getTableList` 的**全部**表(含系统表,等于把平台自己拆了)⇒ 本仓只删「不在 `schema.sql` 里」的表
POST /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Copy implemented DbTableController.java:455 面 B 已落地:`CREATE TABLE … (LIKE … INCLUDING ALL)` ⇒ 主键/NOT NULL/DEFAULT/IDENTITY 一起带过去(官方按字段清单重建会**丢自增**);`type=1` 追加 `INSERT … SELECT *`
GET /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Export partial DbTableController.java:433 面 B 已落地但**恒失败**:官方返 `DownloadVO`(文件服务)⇒ 本仓 `400` + 人话,不返假下载地址
POST /api/system/DataModel/{linkId}/Actions/Import partial DbTableController.java:388 面 B 已落地但**恒失败**:官方读 multipart 的 `.json`;本仓没启 `axum/multipart` ⇒ 明说不支持(前端建模页也没有导入按钮)
[RULER]
# name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败)
# 43 = react 版对齐的 32 条 + 真实业务模块 asset/DataResource 9 条 + 多应用 2 条
+672 -1
View File
@@ -12684,7 +12684,8 @@ async fn db_field_rows(state: &AppState, table: &str) -> Result<Vec<Value>, pgli
CASE WHEN c.character_maximum_length IS NOT NULL \
THEN c.character_maximum_length::text \
WHEN c.data_type = 'numeric' AND c.numeric_precision IS NOT NULL \
THEN c.numeric_precision::text \
THEN c.numeric_precision::text || ',' \
|| COALESCE(c.numeric_scale, 0)::text \
ELSE '0' END AS \"dataLength\", \
CASE WHEN c.is_nullable = 'YES' THEN 1 ELSE 0 END AS \"allowNull\", \
CASE WHEN c.is_identity = 'YES' \
@@ -12969,6 +12970,676 @@ pub async fn data_model_preview(
ok(page_list(paging.current_page, paging.page_size, total, rows))
}
// ---------------------------------------------------------------- 数据建模写面
//
// 🔴 本组是**全仓唯一执行真 DDL** 的地方(`CREATE` / `ALTER` / `DROP TABLE`)。
// 两道护栏缺一不可:
// ① [`db_ident`] 白名单 —— 表名/列名只收 `[A-Za-z_][A-Za-z0-9_]*`,拼进 SQL 前再双引号包裹;
// ② [`is_builtin_table`](`schema.sql` 里 `CREATE TABLE` 过的 35 张)—— 内置表**只给看**,
// 禁改禁删。少这道闸,用户在数据建模页点一下「删除」就能把 `base_user` 干掉,
// 之后连登录都进不来(种子只在空库上跑)。
//
// 官方语义对照(`DbTableController` + `DbTableServiceImpl`):
// - `create`:表名已存在 ⇒ `EXIST001`「名称不能重复」;`checkPrimary` 要求自增只能是
// `int/bigint` 且必须是主键、主键只能是 `varchar/int/bigint` —— 文案逐字照抄;
// - `update`:官方是「建临时表 → 删旧表 → 临时表改名」;本仓用一批 `DROP + CREATE`
// ([`Db::exec`] 走 simple protocol,整批是**隐式事务**,中途失败全回滚)——
// 比官方那三步更安全:它删旧表之后才改名,改失败就两头空;
// - `update` / `delete` 前的 `checkTab` 两道闸:内置表(`DB101`/`DB102`)、
// 表里**有数据**(`DB201`/`DB202`)—— 文案逐字照抄;
// - `addFields` 只 `ADD COLUMN`,**不动**已有列(前端只在 `hasTableData` 时走它,
// 见 `Form.vue:239`:有数据的表只允许追加字段)。
/// 内置表判据 —— `schema.sql` 里 `CREATE TABLE` 过的**全部**表名(当前 35 张)。
///
/// 🔴 判据取自 DDL 真源([`sspf_store::db::ddl_tables`])而不是在这里再抄一份清单:
/// 抄一份的后果是「加了表忘了加护栏」⇒ 新表可以被用户从建模页删掉。
fn is_builtin_table(table: &str) -> bool {
sspf_store::db::ddl_tables().iter().any(|t| t == table)
}
/// 表存在吗(表 / 视图 / 物化视图都算)。
async fn table_exists(state: &AppState, table: &str) -> Result<bool, pglite::Error> {
let rows = state
.db
.query_json_params(
"SELECT 1 AS \"x\" FROM pg_class c \
JOIN pg_namespace n ON n.oid = c.relnamespace \
WHERE n.nspname = current_schema() AND c.relname = $1::text \
AND c.relkind IN ('r', 'v', 'm') LIMIT 1",
&[&table.to_string()],
)
.await?;
Ok(!rows.is_empty())
}
/// 表里有没有数据(`EXISTS`,不 `COUNT(*)` —— 大表上 `COUNT` 会扫全表)。
async fn table_has_data(state: &AppState, table: &str) -> Result<bool, pglite::Error> {
let rows = state
.db
.query_json_params(
&format!("SELECT EXISTS(SELECT 1 FROM \"{table}\" LIMIT 1) AS \"x\""),
&[],
)
.await?;
Ok(rows
.first()
.and_then(|r| r.get("x"))
.and_then(Value::as_bool)
.unwrap_or(false))
}
/// 官方 `DbFieldForm.dataType` 的 7 个编码 ⇒ PG 类型(`None` = 不认识的编码)。
///
/// 🔴 `dataLength` **可能是数字**(`Form.vue` 用 `a-input-number` 绑 `dataLength`)⇒
/// 调用方已经用 [`value_to_text`] 归一成文本,这里只按文本处理。
fn ddl_type(data_type: &str, data_length: &str) -> Option<String> {
let len = data_length.trim();
match data_type.trim() {
"varchar" => {
// PG 的 varchar 上限是 10485760;前端默认 50。
let n: u32 = len
.parse()
.ok()
.filter(|n| (1..=10_485_760).contains(n))
.unwrap_or(50);
Some(format!("varchar({n})"))
}
"text" => Some("text".to_string()),
"int" => Some("integer".to_string()),
"bigint" => Some("bigint".to_string()),
"float" => Some("double precision".to_string()),
// 前端正则 `/^\d+(?:,\d*)?$/` ⇒ `18,4` 或 `18`;解析不出来按 `numeric(18,0)`。
"decimal" => {
let mut it = len.split(',');
let p: u32 = it
.next()
.unwrap_or_default()
.trim()
.parse()
.ok()
.filter(|p: &u32| (1..=1000).contains(p))
.unwrap_or(18);
let s: u32 = it
.next()
.and_then(|v| v.trim().parse().ok())
.unwrap_or(0)
.min(p);
Some(format!("numeric({p},{s})"))
}
"datetime" => Some("timestamp".to_string()),
_ => None,
}
}
/// 一条字段(请求体 `tableFieldList` 的元素,已校验 + 已归一)。
struct DbField {
column: String,
comment: String,
sql_type: String,
allow_null: bool,
primary_key: bool,
identity: bool,
}
/// JSON 值 ⇒ `bool`(`0/1` 数字与 `true/false` 都认)。
///
/// 前端在 `Form.vue:239` 把 `primaryKey/allowNull/identity` 转成 `0/1`,
/// 但 `dataModel.ts` 的调用方未必 ⇒ 两种都收。
fn json_flag(v: Option<&Value>) -> bool {
match v {
Some(Value::Bool(b)) => *b,
Some(Value::Number(n)) => n.as_i64().unwrap_or(0) != 0,
Some(Value::String(s)) => matches!(s.trim(), "1" | "true" | "TRUE"),
_ => false,
}
}
/// 解析并校验 `tableFieldList`(错误码统一 `400` + 人话,文案对齐官方 `checkPrimary`)。
fn parse_db_fields(body: &Value, require_pk: bool) -> Result<Vec<DbField>, String> {
let Some(list) = body.get("tableFieldList").and_then(Value::as_array) else {
return Err("请至少添加一个字段".to_string());
};
if list.is_empty() {
return Err("请至少添加一个字段".to_string());
}
let mut out: Vec<DbField> = Vec::with_capacity(list.len());
let mut seen: HashSet<String> = HashSet::new();
for item in list {
let column = db_ident(
item.get("field")
.and_then(Value::as_str)
.unwrap_or_default(),
)
.ok_or_else(|| "列名格式错误,请重新输入".to_string())?;
if !seen.insert(column.clone()) {
return Err(format!("列名'{column}'已重复"));
}
let data_type = item
.get("dataType")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
let data_length = value_to_text(item.get("dataLength")).unwrap_or_default();
let sql_type = ddl_type(&data_type, &data_length)
.ok_or_else(|| format!("列名{column}的类型不支持"))?;
let primary_key = json_flag(item.get("primaryKey"));
let identity = json_flag(item.get("identity"));
// 🔴 官方 `checkPrimary` 的三条硬规矩(文案逐字照抄)。
if identity && !matches!(data_type.as_str(), "int" | "bigint") {
return Err("自增长ID字段数据类型必须为整形或长整型".to_string());
}
if identity && !primary_key {
return Err("自增字段类型必须为主键".to_string());
}
if primary_key && !matches!(data_type.as_str(), "varchar" | "int" | "bigint") {
return Err("主键必须为字符串或整型、长整型".to_string());
}
out.push(DbField {
column,
comment: item
.get("fieldName")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string(),
sql_type,
allow_null: json_flag(item.get("allowNull")),
primary_key,
identity,
});
}
// 🔴 `addFields` 例外:它只往**已有表**追加列,主键早就在了,
// 这时候还要求「必须选一个主键」会让「加一列」这个动作**永远失败**。
if require_pk && !out.iter().any(|f| f.primary_key) {
return Err("请选择一个字段作为主键".to_string());
}
if out.iter().filter(|f| f.identity).count() > 1 {
return Err("一张表最多只运行有一个自增主键".to_string());
}
Ok(out)
}
/// 字符串 ⇒ SQL 单引号字面量(`'` 翻倍)。
fn sql_literal(raw: &str) -> String {
format!("'{}'", raw.replace('\'', "''"))
}
/// 生成「建表 + 表注释 + 列注释」的**整批** SQL。
///
/// 🔴 一次交给 [`Db::exec`](simple protocol):多语句 = 一个隐式事务 ⇒
/// 建表成功但注释失败时会**整体回滚**,不会留半张没注释的表。
fn create_table_sql(table: &str, comment: &str, fields: &[DbField]) -> String {
let mut parts: Vec<String> = Vec::with_capacity(fields.len() + 1);
for f in fields {
let mut col = format!("\"{}\" {}", f.column, f.sql_type);
if f.identity {
// identity 列**自带** NOT NULL(再写一遍 PG 会报重复约束)。
col.push_str(" GENERATED BY DEFAULT AS IDENTITY");
} else if !f.allow_null {
col.push_str(" NOT NULL");
}
parts.push(col);
}
let pk: Vec<&str> = fields
.iter()
.filter(|f| f.primary_key)
.map(|f| f.column.as_str())
.collect();
if !pk.is_empty() {
// 约束名 `pk_<表名>`:PG 标识符上限 63 字节 ⇒ 表名截到 60。
let short: String = table.chars().take(60).collect();
let cols = pk
.iter()
.map(|c| format!("\"{c}\""))
.collect::<Vec<_>>()
.join(", ");
parts.push(format!("CONSTRAINT \"pk_{short}\" PRIMARY KEY ({cols})"));
}
let mut sql = format!("CREATE TABLE \"{table}\" (\n {}\n);", parts.join(",\n "));
sql.push_str(&format!(
"\nCOMMENT ON TABLE \"{table}\" IS {};",
sql_literal(comment)
));
for f in fields {
if !f.comment.is_empty() {
sql.push_str(&format!(
"\nCOMMENT ON COLUMN \"{table}\".\"{}\" IS {};",
f.column,
sql_literal(&f.comment)
));
}
}
sql
}
/// 把 `pglite` 的报错压成一句人话(前端直接 `createMessage.error(res.msg)`)。
///
/// 🔴 只取**第一行**:PG 的错误正文常带 `DETAIL` / `HINT` 多段,整段塞进 toast 会糊一片。
fn ddl_error(e: &pglite::Error) -> String {
let text = e.to_string();
let first = text.lines().next().unwrap_or_default().trim().to_string();
if first.is_empty() {
"执行失败,请检查表结构".to_string()
} else {
format!("执行失败:{first}")
}
}
/// 请求体里的 `tableInfo` ⇒ `(旧表名, 新表名, 表说明)`,表名都过白名单。
///
/// 🔴 **旧表名可以为空**:新建时前端 `dataForm.table` 就是空串
/// (`Form.vue:24-28` 初始成 `''`,只有编辑态才被 `getInfo` 填上),
/// 把空串当「非法表名」打回去会**永远建不了表**。
fn parse_table_info(body: &Value) -> Result<(String, String, String), String> {
let info = body.get("tableInfo").cloned().unwrap_or(Value::Null);
let field = |key: &str| -> String {
info.get(key)
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string()
};
let old_raw = field("table");
let old = if old_raw.is_empty() {
String::new()
} else {
db_ident(&old_raw).ok_or_else(|| "表名称格式错误,请重新输入".to_string())?
};
// 新建时前端只给 `newTable`(`Form.vue:78`:`dataForm.newTable` 才是输入框绑的值)。
let new_raw = field("newTable");
let new = if new_raw.is_empty() {
old.clone()
} else {
db_ident(&new_raw).ok_or_else(|| "表名称格式错误,请重新输入".to_string())?
};
if new.is_empty() {
return Err("表名称格式错误,请重新输入".to_string());
}
let comment = field("tableName");
if comment.is_empty() {
return Err("表说明不能为空".to_string());
}
Ok((old, new, comment))
}
/// `POST /api/system/DataModel/{linkId}/Table` —— 新建表。
///
/// 🔴 表名撞内置表也报「名称不能重复」:官方先 `isExistTable` 再建,内置表当然存在。
pub async fn data_model_create(
State(state): State<AppState>,
headers: HeaderMap,
Path(_link_id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => Value::Object(o),
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let (_old, new, comment) = match parse_table_info(&obj) {
Ok(v) => v,
Err(msg) => return fail(code::FAIL, msg),
};
if is_builtin_table(&new) {
return fail(code::FAIL, "名称不能重复");
}
// 官方 `createTable` 先 `isExistTable` ⇒ 返回 0 ⇒ `EXIST001`「名称不能重复」。
// 少了这一步会漏到 PG 的 `42P07 relation already exists`(一样是 400,
// 但文案是英文报错,前端直接 toast 给用户看)。
match table_exists(&state, &new).await {
Ok(false) => {}
Ok(true) => return fail(code::FAIL, "名称不能重复"),
Err(e) => return db_error(e, "表存在性判断"),
}
let fields = match parse_db_fields(&obj, true) {
Ok(v) => v,
Err(msg) => return fail(code::FAIL, msg),
};
match state.db.exec(&create_table_sql(&new, &comment, &fields)).await {
Ok(()) => ok(json!("新建成功")),
Err(e) => {
eprintln!("[face-b] 建表失败({new}): {e}");
fail(code::FAIL, ddl_error(&e))
}
}
}
/// `PUT /api/system/DataModel/{linkId}/Table` —— 改表(改名 / 改注释 / 改结构)。
///
/// 🔴 **整表重建**:官方的 `update` 也是重建(`creTable`→`dropTable`→`reTableName`),
/// 所以它前面必须有 `checkTab` 拦「表里有数据」—— 否则改一次结构 = 数据全没。
pub async fn data_model_update(
State(state): State<AppState>,
headers: HeaderMap,
Path(_link_id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => Value::Object(o),
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let (old, new, comment) = match parse_table_info(&obj) {
Ok(v) => v,
Err(msg) => return fail(code::FAIL, msg),
};
if is_builtin_table(&old) {
return fail(code::FAIL, "系统自带表,不允许被编辑");
}
match table_exists(&state, &old).await {
Ok(true) => {}
Ok(false) => return fail(code::FAIL, "获取失败,表不存在"),
Err(e) => return db_error(e, "表存在性判断"),
}
match table_has_data(&state, &old).await {
Ok(false) => {}
Ok(true) => return fail(code::FAIL, "表已经被使用,不允许被编辑"),
Err(e) => return db_error(e, "表数据探测"),
}
if new != old && is_builtin_table(&new) {
return fail(code::FAIL, "名称不能重复");
}
// 改名的目标名已被别的表占了 ⇒ 官方在 `isExistTable` 就拦了(`EXIST001`)。
if new != old {
match table_exists(&state, &new).await {
Ok(false) => {}
Ok(true) => return fail(code::FAIL, "名称不能重复"),
Err(e) => return db_error(e, "新表存在性判断"),
}
}
let fields = match parse_db_fields(&obj, true) {
Ok(v) => v,
Err(msg) => return fail(code::FAIL, msg),
};
// 一批里完成:整体是隐式事务(旧表删了但新表没建起来 ⇒ 回滚,旧表还在)。
let sql = format!(
"DROP TABLE \"{old}\";\n{}",
create_table_sql(&new, &comment, &fields)
);
match state.db.exec(&sql).await {
Ok(()) => ok(json!("修改成功")),
Err(e) => {
eprintln!("[face-b] 改表失败({old} -> {new}): {e}");
fail(code::FAIL, ddl_error(&e))
}
}
}
/// `PUT /api/system/DataModel/{linkId}/addFields` —— 只追加字段(表里已有数据时走这条)。
///
/// 🔴 **只 `ADD COLUMN`,绝不 `DROP`**:前端在有数据的表上把已有字段全锁成 `disabled`
/// (`Form.vue:113-115`),`tableFieldList` 里只剩新加的那几行。
/// 🔴 新列一律**可空**:给非空表加 `NOT NULL` 列会立刻失败(没有默认值可填)。
pub async fn data_model_add_fields(
State(state): State<AppState>,
headers: HeaderMap,
Path(_link_id): Path<String>,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_DATA_MODEL, EN_FORM_DESIGN]).await {
return resp;
}
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => Value::Object(o),
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let (old, new, _comment) = match parse_table_info(&obj) {
Ok(v) => v,
Err(msg) => return fail(code::FAIL, msg),
};
// 前端这条路径上 `table` 与 `newTable` 都是原表名;取不到 `table` 就用 `newTable`。
let table = if old.is_empty() { new } else { old };
if is_builtin_table(&table) {
return fail(code::FAIL, "系统自带表,不允许被编辑");
}
let fields = match parse_db_fields(&obj, false) {
Ok(v) => v,
Err(msg) => return fail(code::FAIL, msg),
};
let mut sql = String::new();
for f in &fields {
sql.push_str(&format!(
"ALTER TABLE \"{table}\" ADD COLUMN IF NOT EXISTS \"{}\" {};\n",
f.column, f.sql_type
));
if !f.comment.is_empty() {
sql.push_str(&format!(
"COMMENT ON COLUMN \"{table}\".\"{}\" IS {};\n",
f.column,
sql_literal(&f.comment)
));
}
}
match state.db.exec(&sql).await {
Ok(()) => ok(json!("修改成功")),
Err(e) => {
eprintln!("[face-b] 加字段失败({table}): {e}");
fail(code::FAIL, ddl_error(&e))
}
}
}
/// `DELETE /api/system/DataModel/{linkId}/Table/{tableName}` —— 删表。
pub async fn data_model_delete(
State(state): State<AppState>,
headers: HeaderMap,
Path((_link_id, table)): Path<(String, String)>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
let Some(table) = db_ident(&table) else {
return fail(code::FAIL, "表名不合法");
};
if is_builtin_table(&table) {
return fail(code::FAIL, "系统自带表,不允许被删除");
}
match table_exists(&state, &table).await {
Ok(true) => {}
Ok(false) => return fail(code::FAIL, "获取失败,表不存在"),
Err(e) => return db_error(e, "表存在性判断"),
}
match table_has_data(&state, &table).await {
Ok(false) => {}
Ok(true) => return fail(code::FAIL, "表已经被使用,不允许被删除"),
Err(e) => return db_error(e, "表数据探测"),
}
match state.db.exec(&format!("DROP TABLE \"{table}\";")).await {
Ok(()) => ok(json!("删除成功")),
Err(e) => {
eprintln!("[face-b] 删表失败({table}): {e}");
fail(code::FAIL, ddl_error(&e))
}
}
}
/// `DELETE /api/system/DataModel/{linkId}/deleteAllTable?dbType=` —— 清空**非内置**表。
///
/// 🔴 **有意收窄**:官方 `deleteAllTable` 把 `getTableList` 拿到的表**全删**(含系统表)——
/// 在本仓等于把平台自己拆了(`base_user` 一没,再也登不回来,种子只在空库上跑)。
/// 这里只删「不是 `schema.sql` 里定义过的」表,也就是用户自己从建模页建的。
pub async fn data_model_delete_all(
State(state): State<AppState>,
headers: HeaderMap,
Path(_link_id): Path<String>,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
// 官方先校验 dbType 与连接一致;本仓只有一个内嵌 PG。
let db_type = crate::platform::sys::query_param(&raw, "dbType");
if !db_type.trim().is_empty() && db_type.trim() != "PostgreSQL" {
return fail(code::FAIL, "数据库类型不符");
}
let rows = match state
.db
.query_json(
"SELECT c.relname AS \"table\" FROM pg_class c \
JOIN pg_namespace n ON n.oid = c.relnamespace \
WHERE n.nspname = current_schema() AND c.relkind = 'r' \
AND c.relname NOT LIKE 'pg\\_%'",
)
.await
{
Ok(rows) => rows,
Err(e) => return db_error(e, "表清单查询"),
};
let victims: Vec<String> = rows
.iter()
.filter_map(|r| r.get("table").and_then(Value::as_str))
.filter(|t| !is_builtin_table(t))
.map(str::to_string)
.collect();
if victims.is_empty() {
return ok(json!("删除成功"));
}
let sql = victims
.iter()
.map(|t| format!("DROP TABLE \"{t}\";"))
.collect::<Vec<_>>()
.join("\n");
match state.db.exec(&sql).await {
Ok(()) => ok(json!("删除成功")),
Err(e) => {
eprintln!("[face-b] 清空表失败: {e}");
fail(code::FAIL, ddl_error(&e))
}
}
}
/// `POST /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Copy` —— 复制表。
///
/// 🔴 用 `CREATE TABLE … (LIKE … INCLUDING ALL)` 而不是「读字段清单再重建」:
/// `INCLUDING ALL` 会把主键、`NOT NULL`、`DEFAULT`、`IDENTITY` 序列一起带过来,
/// 而按字段清单重建会**丢自增**(官方就是这样,复制出来的表 identity 没了)。
/// 注释是唯一 `LIKE` 不带的东西 ⇒ 单独补 `COMMENT ON TABLE`。
pub async fn data_model_copy(
State(state): State<AppState>,
headers: HeaderMap,
Path((_link_id, table)): Path<(String, String)>,
body: Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
let Some(src) = db_ident(&table) else {
return fail(code::FAIL, "表名不合法");
};
let obj = match parse_body(&body) {
Ok(Value::Object(o)) => Value::Object(o),
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let Some(dst) = db_ident(
obj.get("table")
.and_then(Value::as_str)
.unwrap_or_default(),
) else {
return fail(code::FAIL, "表名称格式错误,请重新输入");
};
let comment = obj
.get("tableName")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
if comment.is_empty() {
return fail(code::FAIL, "表说明不能为空");
}
let with_data = obj.get("type").and_then(Value::as_i64).unwrap_or(0) == 1;
match table_exists(&state, &src).await {
Ok(true) => {}
Ok(false) => return fail(code::FAIL, "获取失败,表不存在"),
Err(e) => return db_error(e, "原表存在性判断"),
}
// 新表名撞内置表 / 撞已有表 ⇒ 官方的 `VS032`「数据库表名在整个数据库中应保持唯一」。
match table_exists(&state, &dst).await {
Ok(false) => {}
Ok(true) => return fail(code::FAIL, "数据库表名在整个数据库中应保持唯一"),
Err(e) => return db_error(e, "新表存在性判断"),
}
let mut sql = format!("CREATE TABLE \"{dst}\" (LIKE \"{src}\" INCLUDING ALL);");
if with_data {
// 🔴 不写 `INSERT INTO … SELECT *`:`check-arch` 的 MEM1 把任何 `SELECT *`
// 都当成「整表载入内存」的红线,而且显式列清单顺带保证了列序对齐
// (`LIKE` 复制的列序虽然和源表一致,但写清楚不吃亏)。
let columns: Vec<String> = match db_field_rows(&state, &src).await {
Ok(rows) => rows
.iter()
.filter_map(|r| r.get("field").and_then(Value::as_str).map(str::to_string))
.collect(),
Err(e) => return db_error(e, "复制表取字段"),
};
if columns.is_empty() {
return fail(code::FAIL, "表不存在或字段为空");
}
let list = columns
.iter()
.map(|c| format!("\"{c}\""))
.collect::<Vec<_>>()
.join(", ");
sql.push_str(&format!(
"\nINSERT INTO \"{dst}\" ({list}) SELECT {list} FROM \"{src}\";"
));
}
sql.push_str(&format!(
"\nCOMMENT ON TABLE \"{dst}\" IS {};",
sql_literal(&comment)
));
match state.db.exec(&sql).await {
Ok(()) => ok(json!("复制成功")),
Err(e) => {
eprintln!("[face-b] 复制表失败({src} -> {dst}): {e}");
fail(code::FAIL, ddl_error(&e))
}
}
}
/// `GET /api/system/DataModel/{linkId}/Table/{tableName}/Actions/Export` —— **恒失败**。
///
/// 官方返回 `DownloadVO`(`fileExport.exportFile` ⇒ 落临时文件 + 文件服务域名)。
/// 本仓没有独立的文件服务(同 `BillRule/Actions/Export`)⇒ 给 `400` + 人话,
/// **不返回一个假的下载地址**(前端会拿它去 `location.href`,得到一个 404 页面)。
pub async fn data_model_export(
State(state): State<AppState>,
headers: HeaderMap,
Path((_link_id, table)): Path<(String, String)>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
if db_ident(&table).is_none() {
return fail(code::FAIL, "表名不合法");
}
fail(code::FAIL, "本仓未配置文件服务,暂不支持导出")
}
/// `POST /api/system/DataModel/{linkId}/Actions/Import` —— **恒失败**。
///
/// 官方读 multipart 里的 `.json`(`ModuleTypeEnum.SYSTEM_DBTABLE`)再 `createTable`。
/// 本仓没启 `axum/multipart` ⇒ 收到原始 body 也切不出文件段,
/// 与其「假装收下了」不如明说(前端数据建模页也没有导入按钮)。
pub async fn data_model_import(
State(state): State<AppState>,
headers: HeaderMap,
Path(_link_id): Path<String>,
) -> Json<ActionResult> {
if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await {
return resp;
}
fail(code::FAIL, "本仓未启用文件上传,暂不支持导入")
}
#[cfg(test)]
mod tests {
use super::*;
+42 -1
View File
@@ -411,6 +411,41 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
"/api/system/DataModel/{linkId}/Table/{tableName}/Preview",
get(face_b::data_model_preview),
)
// ---- 数据建模的写面(真 DDL:建表 / 改表 / 加字段 / 删表 / 复制)----
// 🔴 两条护栏在 handler 里:`db_ident` 标识符白名单 + `is_builtin_table`
// (`schema.sql` 定义过的 35 张只给看,禁改禁删)。
.route(
"/api/system/DataModel/{linkId}/Table",
post(face_b::data_model_create),
)
.route(
"/api/system/DataModel/{linkId}/Table",
put(face_b::data_model_update),
)
.route(
"/api/system/DataModel/{linkId}/addFields",
put(face_b::data_model_add_fields),
)
.route(
"/api/system/DataModel/{linkId}/Table/{tableName}",
delete(face_b::data_model_delete),
)
.route(
"/api/system/DataModel/{linkId}/deleteAllTable",
delete(face_b::data_model_delete_all),
)
.route(
"/api/system/DataModel/{linkId}/Table/{tableName}/Actions/Copy",
post(face_b::data_model_copy),
)
.route(
"/api/system/DataModel/{linkId}/Table/{tableName}/Actions/Export",
get(face_b::data_model_export),
)
.route(
"/api/system/DataModel/{linkId}/Actions/Import",
post(face_b::data_model_import),
)
// ---- 系统配置 + 第三方同步(官方 `SysConfigController` / `SynThirdInfoController`)----
.route("/api/system/SysConfig", get(face_b::sys_config_get))
.route("/api/system/SysConfig", put(face_b::sys_config_update))
@@ -1218,7 +1253,7 @@ mod tests {
let port = serve(new_state(db().await)).await;
// 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。
const FACE_B_REGISTERED: [&str; 175] = [
const FACE_B_REGISTERED: [&str; 181] = [
"/api/permission/Users",
"/api/permission/Users/any-id",
"/api/permission/Users/BatchDelete",
@@ -1400,6 +1435,12 @@ mod tests {
"/api/system/DataModel/any-id/Tables/any-table/Fields",
"/api/system/DataModel/any-id/Tables/any-table/Fields/Selector",
"/api/system/DataModel/any-id/Table/any-table/Preview",
"/api/system/DataModel/any-id/Table",
"/api/system/DataModel/any-id/addFields",
"/api/system/DataModel/any-id/deleteAllTable",
"/api/system/DataModel/any-id/Table/any-table/Actions/Copy",
"/api/system/DataModel/any-id/Table/any-table/Actions/Export",
"/api/system/DataModel/any-id/Actions/Import",
];
for path in FACE_B_REGISTERED {
+804
View File
@@ -0,0 +1,804 @@
//! 批次 7(数据建模**写面** `/api/system/DataModel/**`:建表 / 改表 / 加字段 / 删表 / 复制)
//! 集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端页面的一处硬要求):
//! ① 建表成功后 `Table/{t}` 的 `dataLength` 对 `decimal` 必须是 **`18,4`**(带小数位)——
//! 只给精度(`18`)会让前端编辑一次表就把 `numeric(18,4)` 改成 `numeric(18,0)`,**静默丢精度**。
//! ② 表名撞**内置表**(`schema.sql` 定义过的 35 张)⇒ `400 名称不能重复`;
//! 改/删内置表 ⇒ `400 系统自带表,不允许被编辑|删除`(官方 `DB102`/`DB101`)。
//! ③ 表里**有数据**时改结构 / 删表一律拒(官方 `DB202`/`DB201`)——
//! 放行等于让用户在建模页一键抹掉业务数据。
//! ④ `update` 是**重建表**:改名后旧表必须消失、新表字段是请求里的那一套
//! (官方也是 `creTable`→`dropTable`→`reTableName`)。
//! ⑤ `addFields` **只追加、不删列**,且**不要求主键**(主键早就在表上了)。
//! ⑥ `Copy` 的 `type=1` 要带数据(`INSERT … SELECT *`);`LIKE … INCLUDING ALL`
//! ⇒ 主键 / `NOT NULL` / 自增一起过去。
//! ⑦ `Export` / `Import` 恒 `400` + 人话(本仓没有文件服务)—— **不假装成功**。
//!
//! 🔴 pglite-rs 0.2.7 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。
//! 🔴 本文件会**建真表**,所以每个用例用**自己的表名**(串行执行,互不干扰)。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::bootstrap::ensure_base;
use ssw_platform::platform::config::Config;
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::SessionStore;
use ssw_platform::platform::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::{Mutex, OnceCell};
static DB: OnceCell<Db> = OnceCell::const_new();
static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ensure_base(&db).await.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
/// 面 B 请求(带 `Vue-Version: 3`)。
async fn call(
port: u16,
method: &str,
path: &str,
token: &str,
body: Option<&str>,
) -> (String, Value) {
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(10),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let status = head.lines().next().unwrap_or_default().to_string();
let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
(status, json)
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(10),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON");
json["data"]["token"]
.as_str()
.expect("登录必须返回 token")
.to_string()
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch7-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 一个字段(形状照抄 `Form.vue:239` 的 `query.tableFieldList` 元素)。
fn field(name: &str, cn: &str, ty: &str, len: Value, pk: bool, identity: bool) -> Value {
json!({
"field": name,
"fieldName": cn,
"dataType": ty,
"dataLength": len,
"allowNull": if pk { 0 } else { 1 },
"primaryKey": if pk { 1 } else { 0 },
"identity": if identity { 1 } else { 0 },
})
}
/// 建表请求体(`table` 传空串 = 新建;改表时传旧名)。
fn create_body(table: &str, comment: &str, fields: Vec<Value>) -> String {
json!({
"tableInfo": { "table": table, "tableName": comment, "newTable": table },
"tableFieldList": fields,
})
.to_string()
}
// ---------------------------------------------------------------- 建表
/// 建表 → 读回形状 → 重名被拒。`dataLength` 对 `decimal` **必须带小数位**。
#[tokio::test]
async fn create_table_round_trips_and_rejects_duplicate() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = create_body(
"it7_order",
"批次7订单",
vec![
field("id", "主键", "varchar", json!(32), true, false),
field("amount", "金额", "decimal", json!("18,4"), false, false),
field("created_at", "创建时间", "datetime", json!(0), false, false),
field("remark", "备注", "text", json!(0), false, false),
],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "建表应成功: {created}");
assert_eq!(created["data"], "新建成功", "官方 `MsgCode.SU001` 同款: {created}");
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_order",
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "表信息应可读: {info}");
let data = &info["data"];
assert_eq!(data["tableInfo"]["tableName"], "批次7订单", "表注释要落库: {data}");
assert_eq!(data["hasTableData"], false, "新表必须无数据: {data}");
let fields = data["tableFieldList"].as_array().expect("字段必须是数组");
assert_eq!(fields.len(), 4, "{data}");
let amount = fields
.iter()
.find(|f| f["field"] == "amount")
.expect("必须能读回 amount");
// 🔴 只给 `18`(丢了 scale)⇒ 前端编辑一次就把 `numeric(18,4)` 改成 `numeric(18,0)`。
assert_eq!(amount["dataLength"], "18,4", "decimal 必须带小数位: {amount}");
assert_eq!(amount["dataType"], "decimal", "{amount}");
assert_eq!(amount["allowNull"], 1, "{amount}");
let id = fields
.iter()
.find(|f| f["field"] == "id")
.expect("必须能读回 id");
assert_eq!(id["primaryKey"], 1, "主键标记: {id}");
assert_eq!(id["allowNull"], 0, "主键自动 NOT NULL: {id}");
// 再建一次同名 ⇒ 官方 `createTable` 返回 0 ⇒ `EXIST001`「名称不能重复」。
let (_, dup) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(dup["code"], 400, "{dup}");
assert_eq!(dup["msg"], "名称不能重复", "必须是中文人话,不是 PG 的 42P07: {dup}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_order",
&token,
None,
)
.await;
}
/// 建表的三类非法输入:撞内置表 / 无主键 / 类型不支持 / 列名非法 / 自增类型错。
#[tokio::test]
async fn create_table_rejects_bad_schema() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 撞内置表(`base_user` 在 `schema.sql` 里)⇒ 名称不能重复。
let body = create_body(
"base_user",
"用户表",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["code"], 400, "{resp}");
assert_eq!(resp["msg"], "名称不能重复", "{resp}");
// ② 一个主键都没选。
let body = create_body(
"it7_no_pk",
"无主键",
vec![field("a", "a", "varchar", json!(10), false, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["msg"], "请选择一个字段作为主键", "{resp}");
// ③ 类型不在官方那 7 个编码里。
let body = create_body(
"it7_bad_type",
"类型错",
vec![field("a", "a", "blob", json!(10), true, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["msg"], "列名a的类型不支持", "{resp}");
// ④ 列名带空格 ⇒ 白名单拒绝(这也是**唯一**能把字符串拼进 DDL 的入口)。
let body = create_body(
"it7_bad_col",
"列名错",
vec![field("a b", "x", "varchar", json!(10), true, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["msg"], "列名格式错误,请重新输入", "{resp}");
// ⑤ 自增必须是整形(官方 `checkPrimary`)。
let body = create_body(
"it7_bad_identity",
"自增错",
vec![field("id", "主键", "varchar", json!(32), true, true)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(
resp["msg"], "自增长ID字段数据类型必须为整形或长整型",
"{resp}"
);
// ⑥ 合法自增(`int` + 主键)⇒ 建得出来,且读回 `identity=1`。
let body = create_body(
"it7_identity_ok",
"自增表",
vec![field("id", "主键", "int", json!(0), true, true)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["code"], 200, "int 主键自增应建得出来: {resp}");
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_identity_ok",
&token,
None,
)
.await;
let id = &info["data"]["tableFieldList"][0];
assert_eq!(id["identity"], 1, "`GENERATED BY DEFAULT AS IDENTITY` 要读回 1: {id}");
assert_eq!(id["primaryKey"], 1, "{id}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_identity_ok",
&token,
None,
)
.await;
}
// ---------------------------------------------------------------- 内置表护栏
/// 内置表**只给看**:改不行、删不行(少了这道闸,点一下就 `base_user` 没了)。
#[tokio::test]
async fn builtin_tables_cannot_be_altered_or_dropped() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let (_, del) = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/base_user",
&token,
None,
)
.await;
assert_eq!(del["code"], 400, "{del}");
assert_eq!(del["msg"], "系统自带表,不允许被删除", "官方 DB101: {del}");
let body = create_body(
"base_user",
"用户表",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, upd) = call(
port,
"PUT",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(upd["code"], 400, "{upd}");
assert_eq!(upd["msg"], "系统自带表,不允许被编辑", "官方 DB102: {upd}");
// 业务表(`demo_item`)也在 DDL 里 ⇒ 同样受保护。
let (_, del2) = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/demo_item",
&token,
None,
)
.await;
assert_eq!(del2["msg"], "系统自带表,不允许被删除", "{del2}");
}
// ---------------------------------------------------------------- 改表
/// `update` = 重建表:改名 + 加列 + 去列,旧表必须消失。
#[tokio::test]
async fn update_rebuilds_table_and_renames() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = create_body(
"it7_u_old",
"改表前",
vec![
field("id", "主键", "varchar", json!(32), true, false),
field("gone", "将被删的列", "varchar", json!(16), false, false),
],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "{created}");
let body = json!({
"tableInfo": { "table": "it7_u_old", "tableName": "改表后", "newTable": "it7_u_new" },
"tableFieldList": [
field("id", "主键", "varchar", json!(32), true, false),
field("added", "新列", "varchar", json!(64), false, false),
],
})
.to_string();
let (_, upd) = call(
port,
"PUT",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(upd["code"], 200, "改表应成功: {upd}");
assert_eq!(upd["data"], "修改成功", "{upd}");
let (_, old) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_u_old",
&token,
None,
)
.await;
assert_eq!(old["code"], 400, "旧表必须已消失: {old}");
let (_, new) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_u_new",
&token,
None,
)
.await;
assert_eq!(new["code"], 200, "{new}");
assert_eq!(new["data"]["tableInfo"]["tableName"], "改表后", "{new}");
let names: Vec<&str> = new["data"]["tableFieldList"]
.as_array()
.expect("字段必须是数组")
.iter()
.filter_map(|f| f["field"].as_str())
.collect();
assert_eq!(names, vec!["id", "added"], "字段应该是请求里的那一套: {new}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_u_new",
&token,
None,
)
.await;
}
/// `addFields` 只追加:**不要求主键**、旧列一个不动。
#[tokio::test]
async fn add_fields_only_appends_and_needs_no_primary_key() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = create_body(
"it7_add",
"加字段",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "{created}");
// 🔴 请求里**没有主键字段** —— 主键早就在表上,要求它会让「加一列」永远失败。
let body = json!({
"tableInfo": { "table": "it7_add", "tableName": "加字段", "newTable": "it7_add" },
"tableFieldList": [ field("extra", "追加列", "varchar", json!(64), false, false) ],
})
.to_string();
let (_, added) = call(
port,
"PUT",
"/api/system/DataModel/0/addFields",
&token,
Some(&body),
)
.await;
assert_eq!(added["code"], 200, "加字段应成功: {added}");
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_add",
&token,
None,
)
.await;
let names: Vec<&str> = info["data"]["tableFieldList"]
.as_array()
.expect("字段必须是数组")
.iter()
.filter_map(|f| f["field"].as_str())
.collect();
assert_eq!(names, vec!["id", "extra"], "旧列不能被删: {info}");
// 同一个字段再加一次 ⇒ `ADD COLUMN IF NOT EXISTS` ⇒ 不报错、不重复。
let (_, again) = call(
port,
"PUT",
"/api/system/DataModel/0/addFields",
&token,
Some(&body),
)
.await;
assert_eq!(again["code"], 200, "重复加同一列应幂等: {again}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_add",
&token,
None,
)
.await;
}
// ---------------------------------------------------------------- 有数据的表
/// 表里**有数据** ⇒ 改结构 / 删表一律拒(官方 DB202 / DB201)。
#[tokio::test]
async fn table_with_data_is_frozen() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// `base_data_type` 有 7 行种子 ⇒ 复制一份带数据的表。
let body = json!({ "table": "it7_copy_full", "tableName": "带数据副本", "type": 1 }).to_string();
let (_, copied) = call(
port,
"POST",
"/api/system/DataModel/0/Table/base_data_type/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(copied["code"], 200, "复制应成功: {copied}");
let (_, preview) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_copy_full/Preview",
&token,
None,
)
.await;
assert_eq!(
preview["data"]["pagination"]["total"], 7,
"`type=1` 必须把数据一起搬过去: {preview}"
);
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_copy_full",
&token,
None,
)
.await;
assert_eq!(info["data"]["hasTableData"], true, "{info}");
let (_, del) = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_copy_full",
&token,
None,
)
.await;
assert_eq!(del["msg"], "表已经被使用,不允许被删除", "官方 DB201: {del}");
let body = json!({
"tableInfo": { "table": "it7_copy_full", "tableName": "x", "newTable": "it7_copy_full2" },
"tableFieldList": [ field("id", "主键", "varchar", json!(32), true, false) ],
})
.to_string();
let (_, upd) = call(
port,
"PUT",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(upd["msg"], "表已经被使用,不允许被编辑", "官方 DB202: {upd}");
// 重建表会连带数据一起没 ⇒ 确认「拒了之后表和数据都还在」。
let (_, still) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_copy_full/Preview",
&token,
None,
)
.await;
assert_eq!(still["data"]["pagination"]["total"], 7, "拒了就不许动数据: {still}");
}
/// `Copy` 的重名 / 源不存在;`deleteAllTable` 只清**非内置**表。
#[tokio::test]
async fn copy_guards_and_delete_all_spares_builtin() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// 源表不存在。
let body = json!({ "table": "it7_x", "tableName": "x", "type": 0 }).to_string();
let (_, missing) = call(
port,
"POST",
"/api/system/DataModel/0/Table/no_such_table_7/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(missing["msg"], "获取失败,表不存在", "{missing}");
// 复制一张空表,再撞它的名字 ⇒ 官方 VS032。
let body = create_body(
"it7_src",
"源表",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "{created}");
let body = json!({ "table": "it7_src_copy", "tableName": "副本", "type": 0 }).to_string();
let (_, ok_copy) = call(
port,
"POST",
"/api/system/DataModel/0/Table/it7_src/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(ok_copy["code"], 200, "{ok_copy}");
let (_, dup) = call(
port,
"POST",
"/api/system/DataModel/0/Table/it7_src/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(
dup["msg"], "数据库表名在整个数据库中应保持唯一",
"官方 VS032: {dup}"
);
// `deleteAllTable` 的 dbType 必须与库一致。
let (_, bad) = call(
port,
"DELETE",
"/api/system/DataModel/0/deleteAllTable?dbType=MySQL",
&token,
None,
)
.await;
assert_eq!(bad["msg"], "数据库类型不符", "{bad}");
let (_, cleared) = call(
port,
"DELETE",
"/api/system/DataModel/0/deleteAllTable?dbType=PostgreSQL",
&token,
None,
)
.await;
assert_eq!(cleared["code"], 200, "{cleared}");
// 🔴 清空的只是**非内置**表:`base_user` / `demo_item` 必须都还在。
let (_, list) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?pageSize=100",
&token,
None,
)
.await;
let names: Vec<String> = list["data"]["list"]
.as_array()
.expect("表清单必须是数组")
.iter()
.filter_map(|t| t["table"].as_str().map(str::to_string))
.collect();
assert!(names.contains(&"base_user".to_string()), "内置表被误删: {names:?}");
assert!(names.contains(&"demo_item".to_string()), "业务表被误删: {names:?}");
assert!(
!names.contains(&"it7_src".to_string()),
"自建表应被清掉: {names:?}"
);
}
// ---------------------------------------------------------------- 导出 / 导入
/// `Export` / `Import` **恒失败**,且说的是人话(不返假下载地址、不假装收下文件)。
#[tokio::test]
async fn export_and_import_fail_honestly() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let (status, export) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_user/Actions/Export",
&token,
None,
)
.await;
assert!(status.contains("200"), "业务失败也必须 HTTP 200: {status}");
assert_eq!(export["code"], 400, "{export}");
assert!(
export["msg"].as_str().unwrap_or_default().contains("导出"),
"要说明白不支持什么: {export}"
);
let (_, import) = call(
port,
"POST",
"/api/system/DataModel/0/Actions/Import",
&token,
None,
)
.await;
assert_eq!(import["code"], 400, "{import}");
assert!(
import["msg"].as_str().unwrap_or_default().contains("导入"),
"{import}"
);
}