From 6f8dcaa58a6cbcaf8349d578da00d03164b03d6c Mon Sep 17 00:00:00 2001 From: admin Date: Sun, 1 Nov 2026 09:03:21 +0800 Subject: [PATCH] =?UTF-8?q?feat(face-b):=20=E6=95=B0=E6=8D=AE=E5=BB=BA?= =?UTF-8?q?=E6=A8=A1=E5=86=99=E9=9D=A2=E8=90=BD=E5=9C=B0=EF=BC=88=E9=9D=A2?= =?UTF-8?q?=20B=20=E6=89=B9=E6=AC=A1=207=EF=BC=8C+8=20=E7=AB=AF=E7=82=B9?= =?UTF-8?q?=EF=BC=8C=E7=9C=9F=20DDL=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 建表/改表/加字段/删表/清空/复制/导出/导入 八条,均过 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 --- .workbuddy/memory/2026-11-01.md | 46 ++ CLAUDE.md | 4 +- HANDOFF.md | 89 +++- PLAN.md | 2 +- docs/contract.md | 19 +- src/backend/src/platform/face_b.rs | 673 +++++++++++++++++++++++- src/backend/src/routes.rs | 43 +- src/backend/tests/batch7_it.rs | 804 +++++++++++++++++++++++++++++ 8 files changed, 1657 insertions(+), 23 deletions(-) create mode 100644 src/backend/tests/batch7_it.rs diff --git a/.workbuddy/memory/2026-11-01.md b/.workbuddy/memory/2026-11-01.md index b037c63..974ae55 100644 --- a/.workbuddy/memory/2026-11-01.md +++ b/.workbuddy/memory/2026-11-01.md @@ -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(先看页面再定)。 diff --git a/CLAUDE.md b/CLAUDE.md index 7e7b970..3c187fd 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -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 条 diff --git a/HANDOFF.md b/HANDOFF.md index db3c7e7..6573aa8 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -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`。 diff --git a/PLAN.md b/PLAN.md index 52cfceb..ad1a085 100644 --- a/PLAN.md +++ b/PLAN.md @@ -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 | diff --git a/docs/contract.md b/docs/contract.md index 27fecbf..f591b41 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -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 条 diff --git a/src/backend/src/platform/face_b.rs b/src/backend/src/platform/face_b.rs index c96eb7f..da9fe2e 100644 --- a/src/backend/src/platform/face_b.rs +++ b/src/backend/src/platform/face_b.rs @@ -12684,7 +12684,8 @@ async fn db_field_rows(state: &AppState, table: &str) -> Result, 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 { + 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 { + 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 { + 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, 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 = Vec::with_capacity(list.len()); + let mut seen: HashSet = 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 = 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::>() + .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, + headers: HeaderMap, + Path(_link_id): Path, + body: Bytes, +) -> Json { + 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, + headers: HeaderMap, + Path(_link_id): Path, + body: Bytes, +) -> Json { + 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, + headers: HeaderMap, + Path(_link_id): Path, + body: Bytes, +) -> Json { + 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, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, +) -> Json { + 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, + headers: HeaderMap, + Path(_link_id): Path, + raw: RawQuery, +) -> Json { + 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 = 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::>() + .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, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, + body: Bytes, +) -> Json { + 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 = 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::>() + .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, + headers: HeaderMap, + Path((_link_id, table)): Path<(String, String)>, +) -> Json { + 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, + headers: HeaderMap, + Path(_link_id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_DATA_MODEL).await { + return resp; + } + fail(code::FAIL, "本仓未启用文件上传,暂不支持导入") +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 307437e..a30569a 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -411,6 +411,41 @@ pub fn build_router(state: AppState) -> axum::Router { "/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 { diff --git a/src/backend/tests/batch7_it.rs b/src/backend/tests/batch7_it.rs new file mode 100644 index 0000000..7f0217f --- /dev/null +++ b/src/backend/tests/batch7_it.rs @@ -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 = 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) -> 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 = 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}" + ); +}