feat(face-b): 数据连接 + 数据建模只读面落地(面 B 批次 6,+16 端点)

- 新表三张(官方 DDL 逐字):base_db_link(22 列) / base_data_type / base_common_fields,tables 32→35
- 平台字典照官方初始库灌:基准数据类型 7 行 + 常用表字段 10 行(否则建表表单类型下拉全空)
- DataSource 8 条:列表/分组/下拉树(含合成「默认数据库」id=0)/CRUD/测试连接(恒失败不假装)
- DataModel 6 条只读:表清单、表+视图、表信息(hasTableData 真探测)、字段、字段下拉、数据预览
- 🔴 Preview 逐列 "col" AS "col":SELECT * 会被归一成 camelCase ⇒ 前端整表空白
- 尺子补 guard_any(…, &[A,B]) 的守卫推导(官方 mode=OR 那几处)
- 回归 tests/batch6_it.rs(5 条);cargo test --workspace 513 passed
This commit is contained in:
admin committed 2026-11-01 08:29:03 +08:00
1 parent 0d5c43570d
commit 6ed89a33ca
12 files changed
+2131 -22

No files matched your search

+39
View File
@@ -44,3 +44,42 @@
`DataModel/{}/Tables`(被 12 个页面共用,收益最高);其次 `extend`(53) / `systemData`(91),
但这两块多半是「本仓没这个模块」的恒空 stub,先看 §0-bis 的判断再动手。
`visualdev/OnlineDev/{}/Config`(10) 属低代码域,后置。
---
## 面 B 批次 6 —— 数据连接 + 数据建模只读面(16 条)
新增 `base_db_link`(22 列) / `base_data_type` / `base_common_fields`,tables **32 → 35**;
`routes.rs` 加 16 条路由、`FACE_B_REGISTERED` 162 → **175**;`[FACE] B 219 → 235`(合计 265)。
两张平台字典照官方初始库逐字灌:`seed.rs::DATA_TYPES` 7 行 + `COMMON_FIELDS` 10 行。
### 踩到的坑(都写进了 HANDOFF §1「批次 6」)
- **`Preview` 绝不能 `SELECT *`**:`query_json_params` 会把 `f_*` 归一成 camelCase
(`f_en_code` ⇒ `enCode`),而 `Preview.vue:62` 取 `record[column.field.toLowerCase()]`
(原样列名)⇒ 表**整张空白且不报错**。必须逐列 `"col" AS "col"`(双引号别名 = 权威名,
归一逻辑一个字都不动)。这是本批唯一"看起来能跑其实全错"的地方。
- **`DataSource/Selector` 第一组第一项必须是合成「默认数据库」(`id="0"`)**:
`dataModel/index.vue:158-166` 取 `list[0].children[0]` 当默认连接 ⇒ 少了它 `dbType` undefined。
- **`hasTableData` 要 `EXISTS` 真探测**:前端据此把已有字段锁成不可改,`false` ⇒ 用户在有数据的表上删列。
- **密码两条规矩**:详情恒空串(不回明文);`update` 传空串 = 不改(前端编辑时密码框本来就是空的)。
- **`Actions/Test` 恒失败**:本仓只有内嵌 PG,没有驱动层 —— 不假装连上了。
- **`base_db_link` 没有 `f_enabled_mark` 列**(官方 `DbLinkCreUpForm.enabledMark` 必填但落库时被丢弃)
⇒ 接受不落库,读回恒 1。
- **尺子补了一种守卫**:`check-contract-scan.py` 原先只认 `guard(…, CONST)`,
新增 `guard_any(…, &[A, B])` 推导(契约写 `A|B`,**顺序即代码顺序**)。
不加的话官方 `mode=OR` 那几处只能打「推不出」警告。
- **路由段名要与契约逐字一致**:`{table}` vs `{tableName}` 会让 CC3/CC4 各报 4 条漂移 —— 统一成官方的 `{tableName}`。
### 数字(批次 6 收尾)
`cargo test --workspace` **513**(+5)| `fe-gap` **229/900 = 25.4%**
(system 84/196、**systemData 29/106 = 27.4%**,本批从 0 起)
| 契约端点 **265 条(面 B 235)** | 官方覆盖 **254/261(implemented 236 / partial 18 / absent 7)**
| 十二道闸门全绿 | 空载内存 7 MB
### 下一个(批次 7)
数据建模**写面** 8 条(`CREATE/ALTER/DROP TABLE` + `addFields` + `Copy` + `Export`/`Import`)。
动真 DDL 前先立两条护栏:① `base_*` 平台表禁止 ALTER/DROP(只允许看);
② 表名/列名一律过 `db_ident` 白名单再拼 SQL。
+50 -11
View File
@@ -55,8 +55,12 @@
顺手把 `DictionaryData/All` 从「恒空」改成真读字典 + 灌 `businessType` 13 行种子。
详见 §1「批次 5」小节。
**下一个(批次 6)建议**:`DataModel/{}/Tables`(12 页共用,最高优先) +
`extend`/`systemData` 那几个恒空 stub;`visualdev/OnlineDev/{}/Config`(10) 属低代码域,后置。
**下一个(批次 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` 其余族。
**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)**;
@@ -65,16 +69,16 @@
---
## 1. 一句话现状(2026-11-01 批次 5 收尾)
## 1. 一句话现状(2026-11-01 批次 6 收尾)
**📌 当前数字(以此为准,下面各批的「当时数字」仅存档)**:
- 契约端点 **249 条**(面 A 28 + 面 B **219** + 两面共用 2);`tables` → **32**。
- `cargo test --offline --workspace` = **508 passed / 0 failed**。
- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **238/245**
(implemented 225 / partial 13 / absent 7)。
- `python3 scripts/fe-gap.py`:合计 **215 / 900(23.9%)**,`permission` 111/137(81.0%)、
`system` **84/196(42.9%)**。
- 契约端点 **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 起)**。
**✅ 后端已拆成 workspace 多 crate,业务包可独立编译;八道闸门全绿;空载内存 7 MB。**
@@ -210,6 +214,38 @@
- 回归测试 `tests/batch5_it.rs`(**6 条**):登录落日志双读者一致、三条删除路径语义不同、
常用语 CRUD + 计数、单号时间格式 + 跨天归零、规则守卫、随机/UUID 分支。
### 批次 6(2026-11-01)—— 数据连接 + 数据建模只读面
**16 条面 B 端点**:`/api/system/DataSource`(8:列表/分组/下拉树/详/增/改/删/测试连接)
+ `/api/system/BasicDataType`(1:基准类型列表)+ `/api/system/CommonFields`(1:常用字段列表)
+ `/api/system/DataModel/**`(6:表清单 / 表+视图 / 表信息 / 字段 / 字段下拉 / 数据预览)。
- 新表三张(官方 DDL 逐字):`base_db_link`(22 列)/ `base_data_type` / `base_common_fields`;tables 32 → **35**。
- 两张**平台字典**照官方初始库逐字灌(`seed.rs`):`DATA_TYPES` 7 行 + `COMMON_FIELDS` 10 行。
🔴 前者是数据建模表单的**类型下拉唯一数据源**,空了表单虽能开但**建不出表**(不报错)。
- 🔴 **`DataSource/Selector` 的第一组第一项必须是合成的「默认数据库」(`id="0"`)**:
`dataCenter/dataModel/index.vue:158-166` 取 `list[0].children[0]` 当默认连接,
少了它 `dbType` 是 `undefined` ⇒ 建表表单判不出库类型。本仓只有一个库 ⇒ **`linkId` 一律忽略**。
- 🔴 **`Preview` 绝对不能写 `SELECT *`**:`query_json_params` 会把 `f_*` 列名归一成 camelCase
(`f_en_code` ⇒ `enCode`),而 `Preview.vue:62` 取的是 `record[column.field.toLowerCase()]`
(**原样列名**)⇒ 整张表会**空白且不报错**。必须逐列 `"col" AS "col"`(双引号别名是权威名)。
- 🔴 **`hasTableData` 必须真探测**(`EXISTS(SELECT 1 …)`):前端据此把已有字段**锁成不可改**
(`Form.vue:113-115`),给 `false` 会让用户在**有数据**的表上删列 ⇒ 直接丢数据。
- 🔴 **详情不回明文密码**(`password` 恒空串);`update` 传空串 = **不改密码**(前端编辑时密码框本来就空)。
`Actions/Test` **恒业务失败**(本仓没有外部驱动层)—— 刻意不假装连上了。
- 表名/列名收窄成 `[A-Za-z_][A-Za-z0-9_]*`([`db_ident`],比 `valid_table` 宽一点:官方允许 `_` 开头),
只有 `Preview` 会把表名拼进 SQL ⇒ 这段白名单 + 双引号是唯二的注入防线。
- 已知 `partial`:`dbType` 保持编码原样(官方换字典中文名,本仓没灌「系统数据连接」字典);
`CommonFields` 只校验登录(官方要 `dataCenter.dataModel|dataCenter.basicField` 任一,
本仓后者还没登记成点权限);`tableName`/`fieldName` 取 PG 注释,**本仓 schema.sql 没写
`COMMENT ON` ⇒ 全是空串**(数据建模页「说明」列会空,想改就补 `COMMENT ON`)。
- 🔴 **尺子也改了一处**:`check-contract-scan.py` 原先只认 `guard(&state,&headers,CONST)`,
新增 `guard_any(&state,&headers,&[A,B])` 的推导(契约里写 `A|B`,**顺序即代码里的顺序**)
—— 官方 `@SaCheckPermission(..., mode=OR)` 那几处就靠它,否则整条只能打「推不出」警告。
- 回归测试 `tests/batch6_it.rs`(**5 条**):连接的增删改查 + 默认库契约 + 软删三处一致、
两张字典的 7/10 行与 `dataTypeName` 联查、表清单分页/关键词/字段归一/`hasTableData`、
预览分页与单字段模糊、未登录 602。
### 🔴 上一批(第一批)踩到并解决的 4 个真 bug
1. `CurrentUser` 的 `preferenceJson` 必须是**字符串** `"{}"` —— 给对象会让前端
@@ -365,8 +401,11 @@ xop run --secret GU=git_local_user --secret GP=git_local_pass -- bash -c '
5. ~~`system/Log`(5) + `system/CommonWords`(6) + `system/BillRule`(8)~~
✅ **批次 5 做完(实际 21 条)**——新表 `base_sys_log` / `base_common_words` / `base_bill_rule`;
登录落日志 + 常用语 CRUD + 单据规则与单号生成器。
6. `DataModel/{}/Tables`(12 页共用) / `extend`(53) / `systemData`(91) / `file`(32) / 低代码模块
⇒ **下一个**(`file` / `extend` / 低代码多半是恒空 stub,见 §0-bis 的判断)
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` 其余族 ⇒ **下一个**
**实现模板(照抄就行)**:`ORGANIZE_WRITE_FIELDS` / `POSITION_WRITE_FIELDS` 那一套
—— 列白名单 + `now()` 不占参数位 + 只 SET body 里出现的键 + 读回不选 `f_password`。
+1 -1
View File
@@ -251,7 +251,7 @@ ssw-platform/
| 能力 | 现状 | 目标 | 差距 |
|---|---|---|---|
| 面 B 契约端点 | ✅ 219 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) |
| 面 B 契约端点 | ✅ 235 条 | 全量(含 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 |
+9 -5
View File
@@ -1203,30 +1203,31 @@ mod tests {
#[test]
fn schema_sql_has_expected_table_count() {
// schema.sql 必须包含 32 张表的 CREATE TABLE
// (27 张 base_*:8 张官方 + base_system + base_group + base_position
// schema.sql 必须包含 35 张表的 CREATE TABLE
// (30 张 base_*:8 张官方 + base_system + base_group + base_position
// + 字典分类/字典数据 + base_sign_img + base_user_extra
// + base_standing + base_permission_group + base_action
// + base_system_top + base_sys_config(应用中心/系统配置)+ base_tag(标签)
// + base_business_category + base_message + base_notice(消息批次)
// + base_sys_log / base_common_words / base_bill_rule(日志与模板中心批次)
// + base_db_link / base_data_type / base_common_fields(数据建模批次)
// + base_visual_dev / base_visual_release(P2 低代码),+ 4 张业务表)。
//
// 🔴 这个数字**故意写死**:加表必须同时改这里与 main.rs 的 BASE_TABLES,
// 两处都改才算登记完成(漏一处就是「孤儿 DDL」或「白名单多一项」)。
let count = SCHEMA_SQL.matches("CREATE TABLE ").count();
assert_eq!(count, 32, "schema.sql 的 CREATE TABLE 数量应为 32");
assert_eq!(count, 35, "schema.sql 的 CREATE TABLE 数量应为 35");
}
/// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。
#[test]
fn ddl_tables_parses_every_create_table() {
let tables = ddl_tables();
assert_eq!(tables.len(), 32, "ddl_tables 应解析出 32 张表");
assert_eq!(tables.len(), 35, "ddl_tables 应解析出 35 张表");
assert!(tables.iter().all(|t| !t.is_empty()));
assert_eq!(
tables.iter().collect::<std::collections::HashSet<_>>().len(),
32,
35,
"表名不许重复"
);
// 基础 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。
@@ -1248,6 +1249,9 @@ mod tests {
"base_sys_log",
"base_common_words",
"base_bill_rule",
"base_db_link",
"base_data_type",
"base_common_fields",
] {
assert!(
tables.iter().any(|t| t == base),
+34 -1
View File
@@ -1374,6 +1374,22 @@ B PUT /api/system/BillRule/{id} templateCenter.billRule platform
B DELETE /api/system/BillRule/{id} templateCenter.billRule platform
B PUT /api/system/BillRule/{id}/Actions/State templateCenter.billRule platform
B GET /api/system/BillRule/{id}/Actions/Export templateCenter.billRule platform
B GET /api/system/DataSource dataCenter.dataSource platform
B POST /api/system/DataSource dataCenter.dataSource platform
B GET /api/system/DataSource/Selector 登录 platform
B GET /api/system/DataSource/getGroup 登录 platform
B POST /api/system/DataSource/Actions/Test dataCenter.dataSource platform
B GET /api/system/DataSource/{id} dataCenter.dataSource platform
B PUT /api/system/DataSource/{id} dataCenter.dataSource platform
B DELETE /api/system/DataSource/{id} dataCenter.dataSource platform
B GET /api/system/BasicDataType 登录 platform
B GET /api/system/CommonFields 登录 platform
B GET /api/system/DataModel/{linkId}/Tables 登录 platform
B GET /api/system/DataModel/{linkId}/TableAll 登录 platform
B GET /api/system/DataModel/{linkId}/Table/{tableName} dataCenter.dataModel|onlineDev.formDesign platform
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
A GET /api/ssw/demo/DemoItem/List 登录 demo
A POST /api/ssw/demo/DemoItem/Save 登录 demo
A DELETE /api/ssw/demo/DemoItem/Delete 登录 demo
@@ -1390,7 +1406,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset
[FACE]
# face 条数 说明
A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条)
B 219 面 B 专属(官方 JNPF 形状)
B 235 面 B 专属(官方 JNPF 形状)
AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流)
[OFFICIAL]
@@ -1658,6 +1674,23 @@ DELETE /api/system/BillRule/{id} implemented BillRuleController.java:267 面 B
GET /api/system/BillRule/{id}/Actions/Export partial BillRuleController.java:291 面 B 已落地但**恒失败**:官方走 `DataFileExport` 写文件服务,本仓无文件服务 ⇒ `400` + 人话(不假装成功)
POST /api/system/BillRule/Actions/Import partial BillRuleController.java:310 面 B 已落地但**恒失败**:同上,multipart 导入依赖文件服务 ⇒ `400` + 人话
GET /api/system/DataSource/Selector partial DbLinkController.java:81 面 B 已落地:第一组是**合成**「默认数据库」(`id="0"`、`dbType=PostgreSQL`)—— 前端 `dataModel/index.vue:158` 靠 `list[0].children[0]` 取默认连接;真实连接按 `dbType` 分组(官方按「系统数据连接」字典目录分组,本仓没灌那本字典)
GET /api/system/DataSource partial DbLinkController.java:135 面 B 已落地:PageListVO + `creatorUser`=`姓名/账号` + `port` 字符串 + `creatorTime` 毫秒;`dbType` 保持**编码原样**(官方换字典中文名,本仓查不到就是空串 ⇒ 原样更有信息量)
GET /api/system/DataSource/getGroup implemented DbLinkController.java:183 面 B 已落地:按 `host` 分组 `[{host, options:[…]}]`
GET /api/system/DataSource/{id} partial DbLinkController.java:210 面 B 已落地;**`password` 恒空串**:官方回 AES 密文,本仓存明文 ⇒ 绝不外吐
POST /api/system/DataSource implemented DbLinkController.java:224 面 B 已落地:名称判重(`名称已存在`);`enabledMark` 接受但不落库(`base_db_link` 没这列)
PUT /api/system/DataSource/{id} implemented DbLinkController.java:244 面 B 已落地:只 SET body 出现的键;**`password` 空串 = 不改**
DELETE /api/system/DataSource/{id} implemented DbLinkController.java:268 面 B 已落地:软删(官方物理删,本仓保守)
POST /api/system/DataSource/Actions/Test partial DbLinkController.java:288 面 B 已落地但**恒失败**:本仓只有内嵌 PG,没有驱动层 ⇒ `400` + 人话(不假装连上了)
GET /api/system/BasicDataType implemented DataTypeController.java:46 面 B 已落地:`base_data_type` 官方初始库 7 行(`seed.rs::DATA_TYPES` 逐字灌),`ListVO`
GET /api/system/CommonFields partial ComFieldsController.java:64 面 B 已落地:`base_common_fields` 官方 10 行 + `dataTypeName` 联查;官方要求 `dataCenter.dataModel|dataCenter.basicField`,本仓后者未登记成点权限 ⇒ **只校验登录**
GET /api/system/DataModel/{linkId}/Tables implemented DbTableController.java:124 面 B 已落地:真读 `pg_class`(`current_schema()`)+ `obj_description` 注释,PageListVO + keyword/分页;`linkId` **忽略**(本仓只有一个库)
GET /api/system/DataModel/{linkId}/TableAll implemented DbTableController.java:147 面 B 已落地:表 + 视图 + 物化视图(`relkind IN r,v,m`),裸 `ListVO`
GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields implemented DbTableController.java:212 面 B 已落地:`information_schema.columns` + 主键子查询;`dataType` 归一成官方 7 编码,`dataTypeReal` 保留 `udt_name`
GET /api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector implemented DbTableController.java:186 面 B 已落地:与 `Fields` 同源同形(官方也是同一个 `getFieldList`)
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,前端按原样列名取值 ⇒ 整表空白)
[RULER]
# name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败)
# 43 = react 版对齐的 32 条 + 真实业务模块 asset/DataResource 9 条 + 多应用 2 条
+10
View File
@@ -253,6 +253,16 @@ def guard_of_platform(plat_files, mod, fn):
m = re.search(r"guard\(\s*&state\s*,\s*&headers\s*,\s*([A-Z_][A-Z0-9_]*)\s*\)", body)
if m:
return resolve_const(orig, masked, m.group(1))
# 🔴 官方的 `@SaCheckPermission(value={A,B}, mode=OR)` ⇒ 本仓 `guard_any(&[A,B])`:
# 契约里写成 `A|B`(同一个分隔符,**顺序即代码里的顺序**)。
m = re.search(r"guard_any\(\s*&state\s*,\s*&headers\s*,\s*&\[([^\]]*)\]", body)
if m:
codes = []
for name in re.findall(r"\b[A-Z_][A-Z0-9_]*\b", m.group(1)):
value = resolve_const(orig, masked, name)
if value:
codes.append(value)
return "|".join(codes) if codes else None
if re.search(r"require_login_(jnpf|face_b)\s*\(", body):
return "登录"
return None
+93
View File
@@ -707,6 +707,99 @@ CREATE TABLE base_bill_rule (
PRIMARY KEY (f_id, f_tenant_id)
);
-- ----------------------------------------------------------------------------
-- 数据连接(`/api/system/DataSource`)—— 列与官方 JNPF 7.0 逐字一致。
-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1594 行,表名是 `base_db_link`)
-- 🔴 **只登记「外部库」**:本仓自己的库不占一行 —— 官方也是这么做的,
-- `DbLinkController.selectorList` 先塞一个**合成**的「默认数据库」(id = `"0"`,
-- dbType 取当前租户库的类型),再拼真实连接。前端 `dataModel/index.vue` 默认
-- `linkId='0'`,取到的就是这条合成项 ⇒ 本仓 `linkId` 一律**忽略**(只有本机一个库)。
-- 🔴 `f_password` 官方存 AES 密文(`EncryptUtil.encryptByAes`);本仓无该密钥体系
-- ⇒ 原样存取、读回时**不回传明文**(`password` 恒空串),见 `[OFFICIAL]` 的 partial。
-- ----------------------------------------------------------------------------
CREATE TABLE base_db_link (
f_id VARCHAR(50) NOT NULL,
f_full_name VARCHAR(200),
f_db_type VARCHAR(50),
f_host VARCHAR(50),
f_port INTEGER,
f_user_name VARCHAR(50),
f_password VARCHAR(100),
f_service_name VARCHAR(50),
f_description VARCHAR(500),
f_db_schema VARCHAR(50),
f_table_space VARCHAR(50),
f_oracle_param VARCHAR(500),
f_oracle_extend INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- ----------------------------------------------------------------------------
-- 基准数据类型(`/api/system/BasicDataType`)—— 列与官方 JNPF 7.0 逐字一致。
-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1487 行,`base_data_type`)
-- 🔴 **这是平台字典,不是用户数据**:官方初始库 7 行(int / float / decimal /
-- datetime / varchar / text / bigint),本仓在 `platform/seed.rs::DATA_TYPES`
-- 逐字灌同样的 7 行(id 也用官方雪花 id:数据建模表单按 `enCode` 反查)。
-- 🔴 `f_type`:1 系统 / 2 自定义 —— 系统行不允许删(前端也不给删按钮)。
-- ----------------------------------------------------------------------------
CREATE TABLE base_data_type (
f_id VARCHAR(50) NOT NULL,
f_full_name VARCHAR(50),
f_en_code VARCHAR(50),
f_jnpf_key VARCHAR(255),
f_type INTEGER DEFAULT 0,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- ----------------------------------------------------------------------------
-- 常用表字段(`/api/system/CommonFields`)—— 列与官方 JNPF 7.0 逐字一致。
-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1036 行,`base_common_fields`)
-- 🔴 `f_category`:1 缺省字段 / 2 常用字段;官方初始库 10 行全是 `'2'`(常用字段),
-- 本仓 `platform/seed.rs::COMMON_FIELDS` 逐字照抄这 10 行(含官方雪花 id)。
-- 🔴 `f_type`:1 系统 / 2 自定义;`f_allow_delete`:1 允许 / 0 不允许(官方种子是 NULL)。
-- ----------------------------------------------------------------------------
CREATE TABLE base_common_fields (
f_id VARCHAR(50) NOT NULL,
f_category VARCHAR(50),
f_type INTEGER,
f_field_name VARCHAR(50),
f_data_type VARCHAR(50),
f_data_length VARCHAR(50),
f_allow_null INTEGER,
f_allow_delete INTEGER,
f_field VARCHAR(50),
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- ============================================================================
-- 业务表 3 张(demo_item / shop_product / book_shop_book)
--
+8 -2
View File
@@ -45,8 +45,9 @@ use ssw_platform::routes;
/// `base_visual_release`(功能定义与发布快照);应用中心/系统配置批次新增
/// `base_system_top` / `base_sys_config` / `base_tag`;消息批次新增
/// `base_business_category` / `base_message` / `base_notice`;日志与模板中心批次新增
/// `base_sys_log` / `base_common_words` / `base_bill_rule`,故清单现在是 **28 张**。
const BASE_TABLES: [&str; 28] = [
/// `base_sys_log` / `base_common_words` / `base_bill_rule`;数据建模批次新增
/// `base_db_link` / `base_data_type` / `base_common_fields`,故清单现在是 **31 张**。
const BASE_TABLES: [&str; 31] = [
"base_group",
"base_user",
"base_role",
@@ -77,6 +78,11 @@ const BASE_TABLES: [&str; 28] = [
"base_sys_log",
"base_common_words",
"base_bill_rule",
// 🔴 数据建模批次(2026-11-01):数据连接 + 基准数据类型 + 常用表字段。
// 后两张是**平台字典**(官方初始库各灌 7 / 10 行),不是用户数据。
"base_db_link",
"base_data_type",
"base_common_fields",
// 🔴 低代码两张表是**平台表**不是业务表:它们存的是「功能定义」,
// 任何业务模块都会用,属于引擎基础设施。
"base_visual_dev",
File diff suppressed because it is too large. Load diff
+142
View File
@@ -163,6 +163,11 @@ pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite
// 🔴 `businessType` 字典:单据规则(模板中心)的「业务分类」列/下拉的唯一数据源。
// 同样是「缺了不报错、只是全空」的那类,一并种在这里。
ensure_business_type_dict(db, &now).await?;
// 🔴 数据建模的两张平台字典:基准数据类型 + 常用表字段。
// 数据建模的新建表表单**完全依赖**前者(类型下拉),后者是「一键插入常用列」。
// 同样是「缺了不报错、下拉全空」⇒ 一起种在这里。
ensure_data_type(db, &now).await?;
ensure_common_fields(db, &now).await?;
Ok(())
}
@@ -452,6 +457,143 @@ pub async fn ensure_business_type_dict(db: &Db, now: &str) -> Result<(), pglite:
Ok(())
}
/// 基准数据类型(`base_data_type`)—— 官方初始库的 7 行原样。
///
/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 里 `base_data_type` 的 7 条 INSERT。
/// 元组是 `(f_id, f_full_name, f_en_code)`,`f_type = 1`(系统)、`f_jnpf_key = NULL`。
///
/// 🔴 **为什么要灌它**:数据建模的「新建表」表单把类型下拉写死成
/// `getBasicDataTypeList().map(o => ({fullName: o.fullName, id: o.enCode}))`
/// ⇒ 这张表为空时下拉**一个选项都没有**,表单虽然能打开但根本建不出表。
/// 🔴 id 沿用官方雪花 id:`base_data_type_mapping` / `base_data_type_relation`
/// 都按这个 id 关联(本仓暂未建那两张,但先对齐,省得以后迁移对不上)。
const DATA_TYPES: [(&str, &str, &str); 7] = [
("804009215168379011", "整型", "int"),
("804009215168379013", "浮点型", "float"),
("804009215168379014", "小数类型", "decimal"),
("804009215168379016", "日期类型", "datetime"),
("804009215168379017", "字符串", "varchar"),
("804009215168379018", "文本", "text"),
("804009215168379019", "长整形", "bigint"),
];
/// 常用表字段(`base_common_fields`)—— 官方初始库的 10 行原样。
///
/// 真源:`jnpf_db_init.sql` 里 `base_common_fields` 的 10 条 INSERT。
/// 元组是 `(f_id, f_field_name, f_data_type, f_data_length, f_allow_null, f_field)`。
///
/// 🔴 官方这 10 行全是 `f_category = '2'`(**常用字段**)+ `f_type = 2`(自定义)+
/// `f_enabled_mark = 1` + `f_allow_delete = NULL`(不是 0 —— 前端按
/// `allowDelete === 0` 判「不许删」⇒ NULL 与 1 等价,都允许删)。
const COMMON_FIELDS: [(&str, &str, &str, &str, &str, &str); 10] = [
("804368984903285110", "主键", "varchar", "50", "0", "f_id"),
("804368984903285111", "描述", "varchar", "500", "1", "f_description"),
("804368984903285112", "排序码", "bigint", "50", "1", "f_sort_code"),
("804368984903285113", "有效标志", "int", "50", "1", "f_enabled_mark"),
("804368984903285114", "创建时间", "datetime", "50", "1", "f_creator_time"),
("804368984903285115", "创建用户", "varchar", "50", "1", "f_creator_user_id"),
("804368984903285116", "修改时间", "datetime", "50", "1", "f_last_modify_time"),
("804368984903285117", "修改用户", "varchar", "50", "1", "f_last_modify_user_id"),
("804368984903285118", "删除时间", "datetime", "50", "1", "f_delete_time"),
("804368984903285119", "删除用户", "varchar", "50", "1", "f_delete_user_id"),
];
/// 灌基准数据类型(7 行)—— 幂等,按 `f_id` 判存在。
///
/// 🔴 与其它种子同一口径:**不看 `f_delete_mark`**(管理员删掉的不会复活)。
pub async fn ensure_data_type(db: &Db, now: &str) -> Result<(), pglite::Error> {
let now = now.to_string();
let tenant_id = "0".to_string();
let type_system = "1".to_string();
let delete_mark = "0".to_string();
for (index, (id, full_name, en_code)) in DATA_TYPES.iter().enumerate() {
let (id, full_name, en_code) = (id.to_string(), full_name.to_string(), en_code.to_string());
let sort_code = index.to_string();
let existed = db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_data_type WHERE f_id = $1::text LIMIT 1",
&[&id],
)
.await?;
if !existed.is_empty() {
continue;
}
let params: [&(dyn ToSql + Sync); 8] = [
&id,
&full_name,
&en_code,
&type_system,
&sort_code,
&delete_mark,
&tenant_id,
&now,
];
db.exec_params(
"INSERT INTO base_data_type \
(f_id, f_full_name, f_en_code, f_type, f_sort_code, f_delete_mark, f_tenant_id, \
f_creator_time) \
VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text::bigint, \
$6::text::integer, $7::text, $8::text::timestamp)",
&params,
)
.await?;
}
Ok(())
}
/// 灌常用表字段(10 行)—— 幂等,按 `f_id` 判存在。
pub async fn ensure_common_fields(db: &Db, now: &str) -> Result<(), pglite::Error> {
let now = now.to_string();
let tenant_id = "0".to_string();
let category = "2".to_string();
let type_custom = "2".to_string();
let enabled_mark = "1".to_string();
let delete_mark = "0".to_string();
for (index, (id, field_name, data_type, data_length, allow_null, field)) in
COMMON_FIELDS.iter().enumerate()
{
let (id, field_name, data_type) = (id.to_string(), field_name.to_string(), data_type.to_string());
let (data_length, allow_null, field) =
(data_length.to_string(), allow_null.to_string(), field.to_string());
let sort_code = index.to_string();
let existed = db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_common_fields WHERE f_id = $1::text LIMIT 1",
&[&id],
)
.await?;
if !existed.is_empty() {
continue;
}
let params: [&(dyn ToSql + Sync); 13] = [
&id,
&category,
&type_custom,
&field_name,
&data_type,
&data_length,
&allow_null,
&field,
&enabled_mark,
&sort_code,
&delete_mark,
&tenant_id,
&now,
];
db.exec_params(
"INSERT INTO base_common_fields \
(f_id, f_category, f_type, f_field_name, f_data_type, f_data_length, f_allow_null, \
f_field, f_enabled_mark, f_sort_code, f_delete_mark, f_tenant_id, f_creator_time) \
VALUES ($1::text, $2::text, $3::text::integer, $4::text, $5::text, $6::text, \
$7::text::integer, $8::text, $9::text::integer, $10::text::bigint, \
$11::text::integer, $12::text, $13::text::timestamp)",
&params,
)
.await?;
}
Ok(())
}
/// 把一个 `App-Code`(`base_system.f_en_code`)解析成系统 id(`base_system.f_id`)。
///
/// 🔴 用于把菜单种进正确的系统(`f_system_id`)—— 平台层**不认**具体 app 名,
+72 -2
View File
@@ -356,6 +356,61 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
"/api/system/BillRule/{id}/Actions/Export",
get(face_b::bill_rule_export),
)
// ---- 数据连接(官方 `DbLinkController`,路由前缀 `DataSource`)----
// 🔴 `Selector` / `getGroup` 是**静态段**,`{id}` 是参数段 —— matchit 静态优先,
// 两者不冲突(`/DataSource/getGroup` 不会被 `/DataSource/{id}` 抢走)。
.route("/api/system/DataSource", get(face_b::data_source_list))
.route("/api/system/DataSource", post(face_b::data_source_create))
.route(
"/api/system/DataSource/Selector",
get(face_b::data_source_selector),
)
.route(
"/api/system/DataSource/getGroup",
get(face_b::data_source_group),
)
.route(
"/api/system/DataSource/Actions/Test",
post(face_b::data_source_test),
)
.route("/api/system/DataSource/{id}", get(face_b::data_source_info))
.route(
"/api/system/DataSource/{id}",
put(face_b::data_source_update),
)
.route(
"/api/system/DataSource/{id}",
delete(face_b::data_source_delete),
)
// ---- 数据建模的查询面(官方 `DbTableController`,路由前缀 `DataModel`)----
// 🔴 `{linkId}` 一律**忽略**(本仓只有一个内置库);保留段位是为了让
// 官方前端的 URL 形状原样命中。
.route("/api/system/BasicDataType", get(face_b::basic_data_type_list))
.route("/api/system/CommonFields", get(face_b::common_fields_list))
.route(
"/api/system/DataModel/{linkId}/Tables",
get(face_b::data_model_tables),
)
.route(
"/api/system/DataModel/{linkId}/TableAll",
get(face_b::data_model_table_all),
)
.route(
"/api/system/DataModel/{linkId}/Table/{tableName}",
get(face_b::data_model_info),
)
.route(
"/api/system/DataModel/{linkId}/Tables/{tableName}/Fields",
get(face_b::data_model_fields),
)
.route(
"/api/system/DataModel/{linkId}/Tables/{tableName}/Fields/Selector",
get(face_b::data_model_fields_selector),
)
.route(
"/api/system/DataModel/{linkId}/Table/{tableName}/Preview",
get(face_b::data_model_preview),
)
// ---- 系统配置 + 第三方同步(官方 `SysConfigController` / `SynThirdInfoController`)----
.route("/api/system/SysConfig", get(face_b::sys_config_get))
.route("/api/system/SysConfig", put(face_b::sys_config_update))
@@ -1148,7 +1203,7 @@ mod tests {
// 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与
// 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES
// + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。
assert_eq!(body["tables"], 32);
assert_eq!(body["tables"], 35);
assert_eq!(body["version"], env!("CARGO_PKG_VERSION"));
}
@@ -1163,7 +1218,7 @@ mod tests {
let port = serve(new_state(db().await)).await;
// 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。
const FACE_B_REGISTERED: [&str; 162] = [
const FACE_B_REGISTERED: [&str; 175] = [
"/api/permission/Users",
"/api/permission/Users/any-id",
"/api/permission/Users/BatchDelete",
@@ -1330,6 +1385,21 @@ mod tests {
"/api/system/BillRule/any-id",
"/api/system/BillRule/any-id/Actions/State",
"/api/system/BillRule/any-id/Actions/Export",
// —— 数据连接 + 数据建模(批次 6)——
// 🔴 `Selector` / `getGroup` / `Actions/Test` 都是静态段,与 `any-id` 并存不冲突。
"/api/system/DataSource",
"/api/system/DataSource/Selector",
"/api/system/DataSource/getGroup",
"/api/system/DataSource/Actions/Test",
"/api/system/DataSource/any-id",
"/api/system/BasicDataType",
"/api/system/CommonFields",
"/api/system/DataModel/any-id/Tables",
"/api/system/DataModel/any-id/TableAll",
"/api/system/DataModel/any-id/Table/any-table",
"/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",
];
for path in FACE_B_REGISTERED {
+631
View File
@@ -0,0 +1,631 @@
//! 批次 6(数据连接 `/api/system/DataSource` + 基准数据类型 `/api/system/BasicDataType` +
//! 常用表字段 `/api/system/CommonFields` + 数据建模只读面 `/api/system/DataModel/**`)集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端页面的一处硬要求):
//! ① `DataSource/Selector` 的**第一组第一项必须是合成「默认数据库」(`id="0"`)** ——
//! `dataCenter/dataModel/index.vue:158-166` 拿 `list[0].children[0]` 当默认连接,
//! 少了它 `dbType` 是 `undefined` ⇒ 建表表单判不出库类型。
//! ② `DataSource` 列表里 `creatorUser` 是 **`真实姓名/账号`**(官方 `UserService` 同款),
//! `port` 是**字符串**、`creatorTime` 是**毫秒数**(官方 VO 的 `String` / `Long`)。
//! ③ 详情**绝不回传明文密码**(`password` 恒空串);`update` 传空串 = **不改密码**。
//! ④ `Actions/Test` 恒业务失败(本仓没有外部驱动层)—— **不假装成功**。
//! ⑤ 基准数据类型 7 行、常用字段 10 行是**平台字典**,`dataTypeName` 由两张表联查拼出。
//! ⑥ 数据建模的字段列表要给出 `primaryKey` / `allowNull` / `identity` 三个 **1/0** 标记,
//! 且 `dataType` 归一成官方那 7 个编码(DB 里是 `character varying` / `integer`)。
//! ⑦ `Table/{t}` 的 `hasTableData` 决定前端**锁不锁已有字段**
//! (`Form.vue:113-115`)⇒ 有数据必须 `true`,判错会让用户在**有数据**的表上删列。
//!
//! 🔴 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`;`token` 为空串 ⇒ 未登录)。
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-batch6-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 取库里某列(用于验证「空密码不覆盖旧密码」这类**看不见**的行为)。
async fn scalar(db: &Db, sql: &str) -> String {
let rows = db.query_json_params(sql, &[]).await.expect("查询失败");
rows.first()
.and_then(|r| r.get("v"))
.and_then(Value::as_str)
.unwrap_or_default()
.to_string()
}
// ---------------------------------------------------------------- 数据连接
/// 数据连接 CRUD + 下拉树的「默认数据库」契约。
#[tokio::test]
async fn data_source_crud_and_selector_default_group() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 下拉树第一组第一项 = 合成「默认数据库」,id 必须是 "0"(前端 linkId 默认值)。
let (_, sel) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await;
assert_eq!(sel["code"], 200, "下拉树失败: {sel}");
let groups = sel["data"]["list"].as_array().expect("必须是 ListVO");
let first_child = &groups[0]["children"][0];
assert_eq!(first_child["id"], "0", "默认库 id 必须是 0: {sel}");
assert_eq!(first_child["fullName"], "默认数据库", "{sel}");
assert_eq!(first_child["dbType"], "PostgreSQL", "默认库类型: {sel}");
// ② 新建(`enabledMark` 落库时被丢弃 ⇒ 表里没有这列,但不该报错)。
let (_, created) = call(
port,
"POST",
"/api/system/DataSource",
&token,
Some(
&json!({
"fullName": "测试库", "dbType": "MySQL", "host": "192.168.1.9",
"port": "3306", "userName": "root", "password": "p@ss",
"serviceName": "demo", "sortCode": 1, "enabledMark": true
})
.to_string(),
),
)
.await;
assert_eq!(created["code"], 200, "新建失败: {created}");
// ③ 同名再建 ⇒ `400 名称已存在`。
let (_, dup) = call(
port,
"POST",
"/api/system/DataSource",
&token,
Some(&json!({"fullName": "测试库", "dbType": "MySQL"}).to_string()),
)
.await;
assert_eq!(dup["code"], 400, "同名必须拒: {dup}");
assert_eq!(dup["msg"], "名称已存在", "{dup}");
// ④ 列表:PageListVO + `creatorUser` 换成「姓名/账号」+ `port` 是字符串。
let (_, listed) = call(port, "GET", "/api/system/DataSource", &token, None).await;
assert_eq!(listed["code"], 200, "{listed}");
assert_eq!(listed["data"]["pagination"]["total"], 1, "{listed}");
let row = &listed["data"]["list"][0];
assert_eq!(row["fullName"], "测试库", "{row}");
assert_eq!(row["port"], "3306", "port 必须是字符串: {row}");
assert_eq!(row["creatorUser"], "管理员/admin", "{row}");
assert_eq!(row["enabledMark"], 1, "表里没有这列 ⇒ 恒 1: {row}");
assert!(
row["creatorTime"].as_i64().unwrap_or(0) > 1_600_000_000_000,
"creatorTime 必须是毫秒数: {row}"
);
let id = row["id"].as_str().expect("必须有 id").to_string();
// ⑤ 详情:**绝不回传明文密码**。
let (_, info) = call(
port,
"GET",
&format!("/api/system/DataSource/{id}"),
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "{info}");
assert_eq!(info["data"]["password"], "", "不能回传明文密码: {info}");
assert_eq!(info["data"]["userName"], "root", "{info}");
// ⑥ 修改:`password: ""` = **不改密码**(前端编辑时密码框本来就是空的)。
let (_, updated) = call(
port,
"PUT",
&format!("/api/system/DataSource/{id}"),
&token,
Some(&json!({"fullName": "测试库2", "port": "3307", "password": ""}).to_string()),
)
.await;
assert_eq!(updated["code"], 200, "修改失败: {updated}");
let stored = scalar(
db().await,
&format!("SELECT f_password AS \"v\" FROM base_db_link WHERE f_id = '{id}'"),
)
.await;
assert_eq!(stored, "p@ss", "空密码不能把旧密码冲掉");
let port_value = scalar(
db().await,
&format!("SELECT f_port::text AS \"v\" FROM base_db_link WHERE f_id = '{id}'"),
)
.await;
assert_eq!(port_value, "3307", "端口要真的改了");
// ⑦ 下拉树要能看到这一个真实连接(第二组,组名 = dbType)。
let (_, sel2) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await;
let groups = sel2["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(groups.len(), 2, "默认库 + MySQL 一组: {sel2}");
assert_eq!(groups[1]["fullName"], "MySQL", "{sel2}");
assert_eq!(groups[1]["num"], 1, "{sel2}");
// ⑧ 分组视图按 host 分组。
let (_, grouped) = call(port, "GET", "/api/system/DataSource/getGroup", &token, None).await;
assert_eq!(grouped["code"], 200, "{grouped}");
assert_eq!(grouped["data"][0]["host"], "192.168.1.9", "{grouped}");
assert_eq!(grouped["data"][0]["options"][0]["fullName"], "测试库2", "{grouped}");
// ⑨ 测试连接**恒失败**(本仓没有外部驱动层,刻意不假装成功)。
let (_, tested) = call(
port,
"POST",
"/api/system/DataSource/Actions/Test",
&token,
Some(&json!({"dbType": "MySQL", "host": "192.168.1.9"}).to_string()),
)
.await;
assert_eq!(tested["code"], 400, "测试连接必须明确失败: {tested}");
// ⑩ 删除是**软删** ⇒ 列表/分组/下拉三处同时看不到(但库里那行还在)。
let (_, deleted) = call(
port,
"DELETE",
&format!("/api/system/DataSource/{id}"),
&token,
None,
)
.await;
assert_eq!(deleted["code"], 200, "{deleted}");
let (_, after) = call(port, "GET", "/api/system/DataSource", &token, None).await;
assert_eq!(after["data"]["pagination"]["total"], 0, "{after}");
let (_, grouped) = call(port, "GET", "/api/system/DataSource/getGroup", &token, None).await;
assert!(
grouped["data"].as_array().map(Vec::is_empty).unwrap_or(false),
"软删后分组必须空: {grouped}"
);
let (_, sel3) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await;
assert_eq!(
sel3["data"]["list"].as_array().map(Vec::len),
Some(1),
"软删后只剩默认库: {sel3}"
);
let mark = scalar(
db().await,
&format!("SELECT f_delete_mark::text AS \"v\" FROM base_db_link WHERE f_id = '{id}'"),
)
.await;
assert_eq!(mark, "1", "必须是软删(f_delete_mark=1)");
}
// ---------------------------------------------------------------- 两张平台字典
/// 基准数据类型 7 行 + 常用字段 10 行(官方初始库逐字),`dataTypeName` 联查得出。
#[tokio::test]
async fn basic_data_type_and_common_fields_are_seeded() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 基准数据类型:7 行,`enCode` 是数据建模表单里的 value。
let (_, types) = call(port, "GET", "/api/system/BasicDataType", &token, None).await;
assert_eq!(types["code"], 200, "{types}");
let list = types["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(list.len(), 7, "官方初始库 7 行: {types}");
let codes: Vec<&str> = list
.iter()
.map(|r| r["enCode"].as_str().unwrap_or_default())
.collect();
for code in ["int", "float", "decimal", "datetime", "varchar", "text", "bigint"] {
assert!(codes.contains(&code), "缺少 {code}: {types}");
}
assert_eq!(list[0]["type"], 1, "系统行 f_type=1: {}", list[0]);
// ② 常用字段:10 行,`dataTypeName` 必须由 `base_data_type` 拼出来(不是空)。
let (_, fields) = call(port, "GET", "/api/system/CommonFields", &token, None).await;
assert_eq!(fields["code"], 200, "{fields}");
let list = fields["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(list.len(), 10, "官方初始库 10 行: {fields}");
let primary = list
.iter()
.find(|r| r["field"] == "f_id")
.expect("必须有主键字段");
assert_eq!(primary["allowNull"], 0, "主键不允许空: {primary}");
assert_eq!(primary["dataTypeName"], "字符串", "varchar 的中文名: {primary}");
assert_eq!(primary["category"], "2", "官方种子全是常用字段: {primary}");
// `f_allow_delete` 官方种子是 NULL ⇒ 读成 1(允许删),不是 0。
assert_eq!(primary["allowDelete"], 1, "{primary}");
// ③ `category` 过滤生效(1 = 缺省字段,本仓没灌 ⇒ 空)。
let (_, empty) = call(
port,
"GET",
"/api/system/CommonFields?category=1",
&token,
None,
)
.await;
assert_eq!(empty["code"], 200, "{empty}");
assert!(
empty["data"]["list"].as_array().map(Vec::is_empty).unwrap_or(false),
"category=1 应为空: {empty}"
);
}
// ---------------------------------------------------------------- 数据建模只读面
/// 表清单 / 表信息 / 字段 / 下拉 四个读端点的形状与语义。
#[tokio::test]
async fn data_model_tables_info_and_fields() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 表清单:`DbTableListVO`(list + pagination),分页真的生效。
let (_, tables) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?currentPage=1&pageSize=100",
&token,
None,
)
.await;
assert_eq!(tables["code"], 200, "{tables}");
let total = tables["data"]["pagination"]["total"]
.as_i64()
.expect("必须有 total");
// schema.sql 现在是 35 张表;真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。
assert_eq!(total, 35, "表清单必须来自 information_schema: {tables}");
let list = tables["data"]["list"].as_array().expect("必须有 list");
assert!(
list.iter().any(|r| r["table"] == "base_user"),
"表清单里必须有 base_user: {tables}"
);
// `tableName` 取 PG 注释(本仓 schema.sql 没写 COMMENT ON ⇒ 空串,不是 null)。
assert_eq!(list[0]["tableName"], "", "注释为空时给空串: {}", list[0]);
// ② 分页:pageSize=5 只回 5 行,第 2 页与第 1 页不重叠。
let (_, page1) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?currentPage=1&pageSize=5",
&token,
None,
)
.await;
let (_, page2) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?currentPage=2&pageSize=5",
&token,
None,
)
.await;
let p1: Vec<&str> = page1["data"]["list"]
.as_array()
.expect("list")
.iter()
.map(|r| r["table"].as_str().unwrap_or_default())
.collect();
let p2: Vec<&str> = page2["data"]["list"]
.as_array()
.expect("list")
.iter()
.map(|r| r["table"].as_str().unwrap_or_default())
.collect();
assert_eq!(p1.len(), 5, "pageSize 必须生效: {page1}");
assert_eq!(p2.len(), 5, "{page2}");
assert!(
p1.iter().all(|t| !p2.contains(t)),
"两页不许重叠: {p1:?} vs {p2:?}"
);
// ③ keyword 过滤(表名 ILIKE)。
let (_, filtered) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?keyword=bill_rule",
&token,
None,
)
.await;
let hits = filtered["data"]["list"].as_array().expect("list");
assert_eq!(hits.len(), 1, "keyword 必须进 SQL: {filtered}");
assert_eq!(hits[0]["table"], "base_bill_rule", "{filtered}");
// ④ TableAll 是**裸 ListVO**(没有 pagination)。
let (_, all) = call(port, "GET", "/api/system/DataModel/0/TableAll", &token, None).await;
assert_eq!(all["code"], 200, "{all}");
assert!(
all["data"]["pagination"].is_null(),
"TableAll 不许带 pagination: {all}"
);
assert!(
all["data"]["list"]
.as_array()
.map(|l| l.len() >= 35)
.unwrap_or(false),
"{all}"
);
// ⑤ 字段列表:三个 1/0 标记 + `dataType` 归一 + `dataTypeName` 联查。
let (_, fields) = call(
port,
"GET",
"/api/system/DataModel/0/Tables/base_user/Fields?type=0",
&token,
None,
)
.await;
assert_eq!(fields["code"], 200, "{fields}");
let list = fields["data"]["list"].as_array().expect("ListVO");
assert!(!list.is_empty(), "{fields}");
let id_col = list
.iter()
.find(|r| r["field"] == "f_id")
.expect("base_user.f_id 必须在");
assert_eq!(id_col["primaryKey"], 1, "主键标记: {id_col}");
assert_eq!(id_col["allowNull"], 0, "主键非空: {id_col}");
assert_eq!(id_col["identity"], 0, "不是自增: {id_col}");
// DB 里是 `character varying(50)` ⇒ 归一成 `varchar` / `50`。
assert_eq!(id_col["dataType"], "varchar", "{id_col}");
assert_eq!(id_col["dataLength"], "50", "{id_col}");
assert_eq!(id_col["dataTypeName"], "字符串", "{id_col}");
assert_eq!(id_col["columnName"], "f_id", "官方 VO 的 columnName: {id_col}");
// ⑥ `Fields/Selector` 走同一份数据。
let (_, selector) = call(
port,
"GET",
"/api/system/DataModel/0/Tables/base_user/Fields/Selector",
&token,
None,
)
.await;
assert_eq!(selector["code"], 200, "{selector}");
assert_eq!(
selector["data"]["list"].as_array().map(Vec::len),
Some(list.len()),
"Selector 与 Fields 必须同源: {selector}"
);
// ⑦ 表信息:`tableInfo` + `tableFieldList` + `hasTableData`(有数据 ⇒ true)。
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_user",
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "{info}");
assert_eq!(info["data"]["tableInfo"]["table"], "base_user", "{info}");
assert_eq!(info["data"]["hasTableData"], true, "有数据必须 true: {info}");
assert!(
info["data"]["tableFieldList"]
.as_array()
.map(|l| !l.is_empty())
.unwrap_or(false),
"{info}"
);
// ⑧ 表名不存在 / 不合法 ⇒ 业务失败(不是空列表、更不是 500)。
let (_, missing) = call(
port,
"GET",
"/api/system/DataModel/0/Table/no_such_table",
&token,
None,
)
.await;
assert_eq!(missing["code"], 400, "{missing}");
let (_, bad) = call(
port,
"GET",
"/api/system/DataModel/0/Tables/no_such_table/Fields",
&token,
None,
)
.await;
assert_eq!(bad["code"], 400, "{bad}");
let (_, illegal) = call(
port,
"GET",
"/api/system/DataModel/0/Table/a%22b%3Bdrop",
&token,
None,
)
.await;
assert_eq!(illegal["code"], 400, "标识符白名单必须拦住: {illegal}");
assert_eq!(illegal["msg"], "表名不合法", "{illegal}");
}
/// 表数据预览:分页 + 单字段模糊(`Preview.vue` 的搜索表单就这两个参数)。
#[tokio::test]
async fn data_model_preview_paginates_and_filters() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// 拿一张**行数稳定**的表:`base_data_type` 恰好是种子灌的 7 行。
let (_, p1) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?currentPage=1&pageSize=3",
&token,
None,
)
.await;
assert_eq!(p1["code"], 200, "{p1}");
assert_eq!(p1["data"]["pagination"]["total"], 7, "{p1}");
assert_eq!(p1["data"]["list"].as_array().map(Vec::len), Some(3), "{p1}");
let (_, p3) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?currentPage=3&pageSize=3",
&token,
None,
)
.await;
assert_eq!(
p3["data"]["list"].as_array().map(Vec::len),
Some(1),
"第 3 页只剩 1 行: {p3}"
);
// 单字段模糊:`f_en_code ILIKE '%varchar%'` ⇒ 只剩「字符串」那一行。
let (_, filtered) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?field=f_en_code&keyword=varchar",
&token,
None,
)
.await;
assert_eq!(filtered["code"], 200, "{filtered}");
assert_eq!(filtered["data"]["pagination"]["total"], 1, "{filtered}");
let row = &filtered["data"]["list"][0];
assert_eq!(row["f_en_code"], "varchar", "行键必须是真实列名: {row}");
assert_eq!(row["f_full_name"], "字符串", "{row}");
// 只给 keyword、不给 field ⇒ **不加条件**(官方同款:空 field 不过滤)。
let (_, no_field) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?keyword=varchar",
&token,
None,
)
.await;
assert_eq!(no_field["data"]["pagination"]["total"], 7, "{no_field}");
}
/// 未登录 ⇒ 面 B 的 `602`(不是 600,也不是 401)。
#[tokio::test]
async fn data_model_and_data_source_require_login() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
for path in [
"/api/system/DataModel/0/Tables",
"/api/system/DataModel/0/Table/base_user",
"/api/system/DataSource",
"/api/system/DataSource/Selector",
"/api/system/BasicDataType",
"/api/system/CommonFields",
] {
let (status, body) = call(port, "GET", path, "", None).await;
assert!(
status.contains("200"),
"业务失败恒 HTTP 200({path}): {status}"
);
assert_eq!(body["code"], 602, "{path} 未登录必须是 602: {body}");
}
}