From fe9f84b7c1f401af2dc4928ac8a2c75fd74cf0ad Mon Sep 17 00:00:00 2001 From: admin Date: Wed, 4 Nov 2026 22:36:13 +0800 Subject: [PATCH] =?UTF-8?q?refactor(skill):=20=E6=94=B9=E4=B8=BA=E4=BE=9D?= =?UTF-8?q?=E8=B5=96=E5=B7=B2=E5=8F=91=E5=B8=83=E7=9A=84=20sspf=20v0.4.0?= =?UTF-8?q?=EF=BC=8C=E5=88=A0=E9=99=A4=E8=87=AA=E7=A0=94=E5=B9=B3=E5=8F=B0?= =?UTF-8?q?=E3=80=81=E8=BF=81=E5=85=A5=E7=A4=BA=E4=BE=8B=E4=B8=9A=E5=8A=A1?= =?UTF-8?q?=E5=8C=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 平台改由 sspf 门面提供(workspace 锁 git tag v0.4.0),应用瘦成 ~500 行薄壳 - 删除 src/backend/src/platform(17 文件)、routes.rs、bootstrap.rs、db/schema.sql、7 个旧集成测试 - 迁入 4 个示例业务包 packs/{demo,shop,books,asset},依赖从 sspf-sdk 改门面 sspf - 新增 check-scaffold.py(SC1-SC6 + 反自证 6/6)、重写 pack-sync.py、新增 new-pack 与 verify.sh - 删除测「本仓平台实现」的四把静态闸门(platform 搬走后无测量对象,留着即假绿) - 契约补入 asset:MENU_TREE 9 菜单、ENDPOINT +3、FACE A=28 - 前端 dist 入库(后端直接托管,免 npm build) - 验收:check-scaffold 6/6 + 自证 6/6;perm-smoke 32/32;perm-smoke-jnpf 18/18;verify.sh 7/7 --- .gitignore | 4 +- CLAUDE.md | 254 ++- Cargo.lock | 297 ++- Cargo.toml | 49 +- HANDOFF.md | 67 + HOWTO_MODULE.md | 562 ++---- README.md | 111 +- SKILL.md | 197 +- docs/contract.md | 25 +- docs/known-limitations.md | 2 +- docs/runbook.md | 138 +- packs/asset/Cargo.toml | 11 + packs/asset/pack.toml | 37 + packs/asset/schema/001_init.sql | 37 + packs/asset/src/lib.rs | 433 +++++ packs/books/Cargo.toml | 11 + packs/books/pack.toml | 31 + packs/books/schema/001_init.sql | 33 + packs/books/src/lib.rs | 229 +++ packs/demo/Cargo.toml | 11 + packs/demo/pack.toml | 31 + packs/demo/schema/001_init.sql | 29 + packs/demo/src/lib.rs | 207 +++ packs/shop/Cargo.toml | 11 + packs/shop/pack.toml | 31 + packs/shop/schema/001_init.sql | 29 + packs/shop/src/lib.rs | 206 +++ scripts/check-boundary-scan.py | 246 --- scripts/check-boundary.sh | 268 --- scripts/check-citations-scan.py | 570 ------ scripts/check-citations.sh | 150 -- scripts/check-contract-scan.py | 751 -------- scripts/check-contract.sh | 168 -- scripts/check-module.sh | 556 ------ scripts/check-scaffold.py | 374 ++++ scripts/new-pack.py | 438 +++++ scripts/new-pack.sh | 12 + scripts/pack-sync.py | 361 ++++ scripts/verify.sh | 98 + src/backend/Cargo.toml | 36 +- src/backend/db/schema.sql | 252 --- src/backend/src/bootstrap.rs | 29 - src/backend/src/lib.rs | 31 +- src/backend/src/main.rs | 552 +----- src/backend/src/modules/asset.rs | 88 + src/backend/src/modules/books.rs | 130 +- src/backend/src/modules/demo.rs | 114 +- src/backend/src/modules/mod.rs | 288 +-- src/backend/src/modules/shop.rs | 105 +- src/backend/src/packs_gen.rs | 167 ++ src/backend/src/platform/auth.rs | 264 --- src/backend/src/platform/cipher.rs | 213 --- src/backend/src/platform/config.rs | 160 -- src/backend/src/platform/crud.rs | 607 ------- src/backend/src/platform/db.rs | 1091 ------------ src/backend/src/platform/entity.rs | 48 - src/backend/src/platform/envelope.rs | 224 --- src/backend/src/platform/guard.rs | 344 ---- src/backend/src/platform/ids.rs | 54 - src/backend/src/platform/jnpf.rs | 948 ---------- src/backend/src/platform/menu.rs | 43 - src/backend/src/platform/mod.rs | 31 - src/backend/src/platform/permission.rs | 440 ----- src/backend/src/platform/seed.rs | 527 ------ src/backend/src/platform/session.rs | 181 -- src/backend/src/platform/state.rs | 36 - src/backend/src/platform/sys.rs | 1295 -------------- src/backend/src/routes.rs | 759 -------- src/backend/tests/auth_it.rs | 543 ------ src/backend/tests/crud_it.rs | 853 --------- src/backend/tests/db_it.rs | 305 ---- src/backend/tests/guard_it.rs | 166 -- src/backend/tests/permission_it.rs | 669 ------- src/backend/tests/seed_it.rs | 509 ------ src/backend/tests/sys_it.rs | 1883 -------------------- src/frontend/dist/assets/index-BUfssMhg.js | 88 + src/frontend/dist/index.html | 12 + 77 files changed, 4151 insertions(+), 17009 deletions(-) create mode 100644 packs/asset/Cargo.toml create mode 100644 packs/asset/pack.toml create mode 100644 packs/asset/schema/001_init.sql create mode 100644 packs/asset/src/lib.rs create mode 100644 packs/books/Cargo.toml create mode 100644 packs/books/pack.toml create mode 100644 packs/books/schema/001_init.sql create mode 100644 packs/books/src/lib.rs create mode 100644 packs/demo/Cargo.toml create mode 100644 packs/demo/pack.toml create mode 100644 packs/demo/schema/001_init.sql create mode 100644 packs/demo/src/lib.rs create mode 100644 packs/shop/Cargo.toml create mode 100644 packs/shop/pack.toml create mode 100644 packs/shop/schema/001_init.sql create mode 100644 packs/shop/src/lib.rs delete mode 100644 scripts/check-boundary-scan.py delete mode 100755 scripts/check-boundary.sh delete mode 100644 scripts/check-citations-scan.py delete mode 100644 scripts/check-citations.sh delete mode 100644 scripts/check-contract-scan.py delete mode 100644 scripts/check-contract.sh delete mode 100755 scripts/check-module.sh create mode 100755 scripts/check-scaffold.py create mode 100755 scripts/new-pack.py create mode 100755 scripts/new-pack.sh create mode 100755 scripts/pack-sync.py create mode 100755 scripts/verify.sh delete mode 100644 src/backend/db/schema.sql delete mode 100644 src/backend/src/bootstrap.rs create mode 100644 src/backend/src/modules/asset.rs create mode 100644 src/backend/src/packs_gen.rs delete mode 100644 src/backend/src/platform/auth.rs delete mode 100644 src/backend/src/platform/cipher.rs delete mode 100644 src/backend/src/platform/config.rs delete mode 100644 src/backend/src/platform/crud.rs delete mode 100644 src/backend/src/platform/db.rs delete mode 100644 src/backend/src/platform/entity.rs delete mode 100644 src/backend/src/platform/envelope.rs delete mode 100644 src/backend/src/platform/guard.rs delete mode 100644 src/backend/src/platform/ids.rs delete mode 100644 src/backend/src/platform/jnpf.rs delete mode 100644 src/backend/src/platform/menu.rs delete mode 100644 src/backend/src/platform/mod.rs delete mode 100644 src/backend/src/platform/permission.rs delete mode 100644 src/backend/src/platform/seed.rs delete mode 100644 src/backend/src/platform/session.rs delete mode 100644 src/backend/src/platform/state.rs delete mode 100644 src/backend/src/platform/sys.rs delete mode 100644 src/backend/src/routes.rs delete mode 100644 src/backend/tests/auth_it.rs delete mode 100644 src/backend/tests/crud_it.rs delete mode 100644 src/backend/tests/db_it.rs delete mode 100644 src/backend/tests/guard_it.rs delete mode 100644 src/backend/tests/permission_it.rs delete mode 100644 src/backend/tests/seed_it.rs delete mode 100644 src/backend/tests/sys_it.rs create mode 100644 src/frontend/dist/assets/index-BUfssMhg.js create mode 100644 src/frontend/dist/index.html diff --git a/.gitignore b/.gitignore index dafa5ce..e35f14e 100644 --- a/.gitignore +++ b/.gitignore @@ -9,8 +9,10 @@ src/backend/data.bak-*/ # 前端 src/frontend/node_modules/ -src/frontend/dist/ src/frontend/.vite/ +# 🔴 `src/frontend/dist/` **故意不忽略**(2026-11-04):前端产物随仓走 +# ⇒ 后端 `static_dir` 直接托管,不需要先 `npm install && npm run build`。 +# 重新构建后记得把产物一起提交(`npm --prefix src/frontend run build`)。 # SDD 工作区(git-ignored 草稿) .superpowers/ diff --git a/CLAUDE.md b/CLAUDE.md index ad657f7..3c1d64e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -6,7 +6,13 @@ ## 项目定位 -**ssw-jnpf-lite-rust** = **JNPF 兼容契约的 Rust 实现**(单二进制、零外部服务)。 +**ssw-jnpf-lite-rust** = **JNPF 兼容契约的 Rust 业务样板**(单二进制、零外部服务)。 + +🔴 **平台不在本仓**(2026-11-04 架构变更):登录 / 权限 / 面 A·B / 低代码 / MCP / 177 张 +`base_*` 表在**已发布的 `sspf` 包**里(`Cargo.toml` 的 `git` + `tag = "v0.4.0"`)。 +本仓只有 **业务包 `packs/` + 面 A 适配器 `modules/` + 薄装配 `main.rs` + 前端产物 + 两把尺子**。 +以前这里有一份 4000 行的平台实现(`src/backend/src/platform/` + `routes.rs`),已整体删除 —— +**不要把它抄回来**:`python3 scripts/check-scaffold.py` 的 SC1 会立刻红。 它的存在意义只有一条:**让"用 Rust 写业务"和"迁回官方 JNPF(Java)"之间是机械翻译,而不是重写。** 为此本仓的**数据模型(表名/列名/语义)与 HTTP 契约**从第一天就锁死成官方 JNPF 的形状。 @@ -29,25 +35,29 @@ ### 交付形态 -v1 = **全量契约对齐**:登录 / `CurrentUser` / 5 组 `base_*` 管理 CRUD / 统一授权 / -四源权限合并 / 两段式种子 / 3 个业务模块(demo · shop · books)/ 权限闭环冒烟。 -先做**真实项目**,跑通验收门之后**再抽成技能**(技能资产形态 = 本仓 1:1 复制)。 +**当前形态**(2026-11-04 起)= **示例业务仓**: +4 个业务包(demo · shop · books · asset)+ 面 A 适配器 + 薄装配 + 前端产物 + +两把运行时尺子(面 A 32 条 / 面 B 18 条)+ 6 条静态判据(`check-scaffold.py`)。 -v1.1 = **双面后端(面 A + 面 B)**:**同一进程**同时提供 -**面 A**(ssw/react 契约,27 条路由,**冻结**)与 -**面 B**(官方 JNPF 契约,5 条路由 + 2 条共用路由按判别头分流), -两套返回形状、**两套权限判据**(面 A 按菜单路径 / 面 B 按 `f_en_code` 点权限), -但**同一套 `base_*` 表 / 同一套 cipher / 同一套 seed**。 -六道闸门:四道**静态闸门**(`scripts/check-module.sh` 10 接触点 + `scripts/check-boundary.sh` -分层红线 CP1–CP6 + `scripts/check-contract.sh` 契约端点表 + **官方端点台账** ↔ 代码真实路由 CC2–CC10 + -`scripts/check-citations.sh` 文档引文 `路径:行号` CIT1–CIT3)+ -两把**契约尺子**(`scripts/perm-smoke.sh` 面 A 32 条 + -`scripts/perm-smoke-jnpf.sh` 面 B 18 条)。 -📊 **官方端点覆盖账本** = 契约附录 A 的 `[OFFICIAL]`(53 行,四态 -`implemented`/`partial`/`absent`/`oos`)⇒ CC10 与代码真实路由**双向**对账 ⇒ -打印「官方端点覆盖 **N/M**」(当前 8/47)—— **算出来的,不是人数的**。 -用途不是"再做一个 JNPF 后台",而是**双向快速移植/验证的框架**: -Rust 版 ⇒ 可机械翻译回官方 JNPF;JNPF / React 版 ⇒ 可打到本框架跑起来验证。 +- **平台能力**由 `sspf` 包提供:登录 / `CurrentUser` / 5 组 `base_*` 管理 CRUD / 统一授权 / + 四源权限合并 / 两段式种子 / 面 B 官方形状 / 低代码 / MCP / 177 张平台表。 +- **本仓负责**:业务表 + 列 + 菜单 + 面 B 路由(在 `packs//`)、面 A 适配器、 + 把两者交给 `sspf::Platform`、以及证明「业务真的能跑」的尺子。 + +**判据(两类,别按旧的「六道闸门」理解)** + +| | 命令 | 判据 | +|---|---|---| +| 静态 | `python3 scripts/check-scaffold.py`(+ `--self-test`) | 本仓只准有业务(SC1–SC6,自证 6/6) | +| 静态 | `python3 scripts/pack-sync.py --check` | 生成物不漂移 | +| 测试 | `cargo test --workspace` | 包自检 + 应用装配 | +| 运行时 | `bash scripts/perm-smoke.sh` | 面 A 32 条 | +| 运行时 | `bash scripts/perm-smoke-jnpf.sh` | 面 B 18 条(覆盖 N/18) | +| 一键 | `bash scripts/verify.sh` / `--fast` | 上面全部 | + +🔴 **旧的 `check-module.sh` / `check-boundary.sh` / `check-contract.sh` / `check-citations.sh` 已删除**: +它们测的是本仓那份平台实现(分层 / 契约对账 / 引文),平台搬走后**没有测量对象**, +留着只会假绿。 ## 技术栈 @@ -67,75 +77,44 @@ Rust 版 ⇒ 可机械翻译回官方 JNPF;JNPF / React 版 ⇒ 可打到本 ``` ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · ~/.claude · ~/.workbuddy 都指向这里 -├── SKILL.md # 【技能入口】是什么 / 何时用 / 契约红线 / 六道闸门 +├── SKILL.md # 【技能入口】是什么 / 何时用 / 契约红线 / 判据 ├── README.md # 选型 / 运行 / 验收门 / 已知限制 -├── HOWTO_MODULE.md # 加一个业务模块的操作手册(9 个接触点) +├── HOWTO_MODULE.md # 加一个业务模块(一条命令 + 四个文件) ├── PERMISSION.md # 权限模版:表结构 / 四源合并 / 码表 -├── MIGRATION.md # 迁移指南(Rust ⇄ NestJS ⇄ 官方 JNPF Java)+ 数据 ETL + 口令换算 -├── JNPF_SOURCE_AUDIT.md # 官方源码逐行核对报告(每条带 文件:行号) -├── JNPF_COMPAT_SURFACE.md # 面 B(官方 JNPF 契约面)规格书 + 落地顺序 S1–S6 -├── Cargo.toml # 【workspace 根】members = ["src/backend"];release profile 写在这里 +├── MIGRATION.md # 迁移指南(Rust ⇄ NestJS ⇄ 官方 JNPF Java) +├── JNPF_SOURCE_AUDIT.md # 官方源码逐行核对报告 +├── JNPF_COMPAT_SURFACE.md # 面 B 规格书 + 落地顺序 S1–S6 +├── Cargo.toml # 【workspace 根】members = ["src/backend", "packs/*"] +│ # 🔴 唯一的平台依赖:sspf = { git = "...", tag = "v0.4.0" } ├── CLAUDE.md / HANDOFF.md # 本文件 / 交接文档 ├── run.sh # install / build / dev / backend / frontend / stop / logs -├── .env.example # PORT / PGLITE_DIR(后者只能写绝对路径或 memory://) +├── packs/ # 【业务真源】整目录可搬;每个包只依赖 sspf 门面 +│ └── {demo,shop,books,asset}/ +│ ├── Cargo.toml # 只依赖 sspf(出现 axum/tokio/pglite ⇒ SC4 红) +│ ├── pack.toml # 清单:app_code / 表 / 契约版本区间 +│ ├── schema/001_init.sql # 建表(带 f_tenant_id + 复合主键;不许建 base_*) +│ └── src/lib.rs # 列 + spec + 菜单 + 面 B 路由 + impl BusinessPack for Pack +├── src/ +│ ├── backend/ # 示例应用(薄壳,~500 行) +│ │ ├── src/main.rs # --enc/--help + ssfp::Platform 装配 + serve +│ │ ├── src/lib.rs # pub mod modules; pub mod packs_gen; +│ │ ├── src/packs_gen.rs # 业务包清单(生成物:load_static + manifest 快照) +│ │ ├── src/modules/ # 面 A 适配器(生成段 + 3 个 handler/模块) +│ │ └── data/ # pglite 数据目录(gitignore) +│ └── frontend/ # React + Vite(含已打好的 dist/,后端直接托管) +├── scripts/ +│ ├── verify.sh # 一键验收(7 步 / --fast 4 步) +│ ├── check-scaffold.py # 静态判据 SC1–SC6 + --self-test 6/6 +│ ├── pack-sync.py # 四处派生位置的生成器(--check 防漂移) +│ ├── new-pack.sh/.py # 造包脚手架 +│ ├── perm-smoke.sh # 面 A 尺子(32 条) +│ ├── perm-smoke-jnpf.sh # 面 B 尺子(18 条) +│ ├── smoke_backend.sh # 隔离后端自启动助手(被两把尺子 source) +│ ├── contract_expect.py # 读 docs/contract.md 附录 A(尺子的唯一期望源) +│ ├── reap-ipc-leaks.sh / ipc-reap.c # macOS SysV 信号量回收 ├── references/ # BaseCrudController.java(**非** JNPF 官方类)+ README ├── template-boot-jnpf/ # JNPF 标准栈最小可运行骨架(Java) -├── docs/ -│ ├── contract.md # 【契约唯一真源】端点 / 返回形状 / 数据模型 -│ ├── runbook.md # 怎么起 / 怎么冒烟 / 常见故障 -│ ├── decisions.md # 实施期逐条裁决(98 条「什么—为什么—代价」) -│ ├── known-limitations.md # 分支级已知限制(被接受/挂起的东西) -│ ├── README-project.md # 项目定位 / 启动方式 / 验收门(历史版 README) -│ └── ddl/ # 官方 DDL 摘录 -├── src/ -│ ├── backend/ # Rust 后端(workspace 唯一成员,crate 名 ssw-jnpf-lite-rust) -│ │ ├── Cargo.toml -│ │ ├── src/ -│ │ │ ├── main.rs # 启动装配 -│ │ │ ├── lib.rs # 模块清单:pub mod platform / modules / routes -│ │ │ ├── platform/ # 【平台层】加业务模块**一个字都不改**(对齐 react 的 common+auth+sys / 官方 jnpf-common+jnpf-system) -│ │ │ │ ├── mod.rs # 平台层模块清单 + 分层说明 -│ │ │ │ ├── config.rs # 环境变量 -│ │ │ │ ├── db.rs # pglite 封装 + schema 初始化 -│ │ │ │ ├── cipher.rs # md5 + AES-256-ECB(对齐 cipher.ts) -│ │ │ │ ├── envelope.rs # ActionResult{code,msg,data} -│ │ │ │ ├── ids.rs # 36 位 UUID v4 -│ │ │ │ ├── session.rs # 内存 token 表 -│ │ │ │ ├── state.rs # AppState -│ │ │ │ ├── auth.rs # 登录 / CurrentUser / 鉴权守卫(面 A/面 B 共用) -│ │ │ │ ├── jnpf.rs # 【面 B】官方 JNPF 形状:判别头 / PcUserVO / PageListVO / 点权限守卫 -│ │ │ │ ├── permission.rs# 四源合并 + 管理员短路 + 菜单树 -│ │ │ │ ├── seed.rs # ensureBase + firstSeed -│ │ │ │ ├── sys.rs # 5 组 base_* 显式 handler -│ │ │ │ ├── entity.rs # 业务实体 spec 的**类型**(不含任何业务 spec) -│ │ │ │ ├── menu.rs # 内置菜单 spec 的**类型**(不含任何业务菜单) -│ │ │ │ ├── guard.rs # 生产档弱密钥守卫(六条判据;SSW_PROFILE=prod 才生效) -│ │ │ │ └── crud.rs # spec 驱动的通用 CRUD 引擎(不含业务表名/app_code) -│ │ │ ├── modules/ # 【业务层】加业务模块**只改这里** -│ │ │ │ ├── mod.rs # ALL_SPECS + ALL_MENUS + ALL_ROUTES + router() 汇总 -│ │ │ │ ├── demo.rs # DemoItem(demo_item)+ DEMO_MENU -│ │ │ │ ├── shop.rs # Product(shop_product)+ PRODUCT_MENU -│ │ │ │ └── books.rs # Book(book_shop_book)+ BOOK_MENU -│ │ │ └── routes.rs # 路由装配(平台 27 条 + 面 B 5 条 + merge 业务路由) -│ │ ├── bootstrap.rs # 【装配根】唯一同时认识平台层与业务层的地方(把业务菜单注入平台层种子) -│ │ ├── db/schema.sql # 完整 DDL(base_* 7 张 + 3 业务表) -│ │ └── data/ # 运行期数据(gitignore) -│ └── frontend/ # react 技能前端逐字复制(**只改** vite.config.ts 的代理端口 30000→30010) -├── scripts/ -│ ├── perm-smoke.sh # 权限闭环冒烟(32 条断言,零 node 依赖)—— 面 A 尺子 -│ ├── perm-smoke-jnpf.sh # 官方 JNPF 形状冒烟(18 条断言)—— 面 B 尺子(**已全绿 18/18**) -│ ├── smoke_backend.sh # 两把尺子的「隔离后端」自启动助手(被 source;显式给了 B ⇒ 不自起) -│ ├── check-module.sh # 业务模块 10 接触点静态自检(纯静态,不起后端) -│ ├── check-boundary.sh # 分层红线自检(CP1–CP6,纯静态)—— 平台层不许有业务知识 -│ ├── check-boundary-scan.py # CP1 的扫描器(业务标识符清单**从业务层派生**)+ 反自证 -│ ├── check-contract.sh # 契约端点表 ↔ 代码真实路由 静态对账(CC2–CC10,纯静态) -│ ├── check-contract-scan.py # 上面那个的扫描器(Rust 源码静态解析:路由/方法/守卫)+ 9 例反自证 -│ ├── check-citations.sh # 文档引文 `路径:行号` 静态核对(CIT1–CIT3,纯静态) -│ ├── check-citations-scan.py # 上面那个的扫描器(引文解析 + DDL 行号表核对)+ 3 例反自证 -│ ├── contract_expect.py # 读 docs/contract.md 附录 A(机器可读期望值)—— 六把尺子的唯一期望源 -│ ├── reap-ipc-leaks.sh # macOS SysV 信号量回收(cargo test 跑多了会攒) -│ └── ipc-reap.c # 上面那个的 C 实现(nsems==20 是 PGlite 指纹) -└── .gitignore +└── docs/ # contract.md(契约真源)/ runbook / decisions / known-limitations / ddl ``` ## 架构红线 @@ -156,8 +135,8 @@ ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · 5. 🔴 **口令不得外泄。** 库内存 `md5(明文)`;对外响应**手工挑字段**(用户列表要**去掉 `password`**)。 密文只在请求体里出现,永不回显。 6. 🔴 **前端不直接持有数据库。** 一切访问经 `/api/**`。 -7. 🔴 **schema DDL 绝不可从 HTTP 下载。** `db/schema.sql` **不在 web root**, - 且要有兜底守卫(`/api/**` 之外的静态托管只放前端产物)。 +7. 🔴 **DDL 绝不可从 HTTP 下载。** 平台 DDL 已 `include_str!` 进 `sspf` 二进制(不在任何 web root); + 业务 DDL 在 `packs//schema/` 里,**同样不许**放进 `src/frontend/` 或任何静态目录。 8. 🔴 **同一文件的多个 Edit 必须串行**(并行 Edit = last-writer-wins 静默覆盖)。 改完**必须 grep 复核**全部改动点。 9. 🔴 **面 A / 面 B 的判别头是 `Vue-Version: 3`**,不是 `Jnpf-Origin: pc`。 @@ -165,7 +144,8 @@ ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · 而本仓前端 `src/frontend/src/api/request.ts` **也发**前两个(与官方同款)、 **只不发** `Vue-Version` ⇒ 判别只能用后者。 🔴 **本仓前端禁止发 `Vue-Version`**(发了 ⇒ 面 A 请求被误判成面 B ⇒ 契约整体错位)。 - `scripts/check-module.sh` 的「全局红线」段**静态钉住**这一条 + 面 B 尺子必须带该头。 + 面 B 尺子(`scripts/perm-smoke-jnpf.sh`)**必须带该头**;本仓前端不发该头是硬约束 + (改了 `request.ts` 就会让面 A 请求被判成面 B ⇒ 两把尺子同时红)。 10. 🔴 **两套权限判据并存,别混。** - 面 A 守卫按**菜单路径**(`base_module.f_url_address`,见红线 4); - 面 B 守卫按**点权限编码**(`base_module.f_en_code`,官方 `@SaCheckPermission("permission.user")`)。 @@ -173,27 +153,20 @@ ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · 🔴 **同一用户可能在面 A 通、面 B 拒**(这不是 bug,是两套判据)——改动任一套都不许动另一套。 11. 🔴 **面 B 未登录返 `code=602`**,不是 `600`。官方前端 `request.ts` 只对 `601`/`602` 清 token ⇒ 返 `600` 会让官方前端卡死不跳登录页。面 A 仍是 `600`(**冻结**)。 -12. 🔴 **平台层 / 业务层分离。** - - **平台层** `src/backend/src/platform/` = 契约实现(信封 / cipher / 登录 / 权限 / - `base_*` 管理 / 面 B / CRUD 引擎)—— **不许出现业务知识**(表名 / app_code / 菜单 key)。 - - **业务层** `src/backend/src/modules/` = 业务 spec + **自己的菜单** + handler + 自己的 `router()`。 - - **加一个业务模块只碰业务层**(`modules/.rs` + `modules/mod.rs`)⇒ - **平台层一个字都不改**(路由由业务层自带,平台层只 `merge(modules::router())` 一次)。 - - 🔴 **业务路由清单住在业务层**(`modules/.rs` 的 `ROUTES` ⇒ `modules::ALL_ROUTES`) - ⇒ 平台层的路由表钉子测试遍历它 ⇒ 加模块不必改平台层的测试。 - - 🔴 **业务菜单也住在业务层**(`modules/.rs` 的 `*_MENU: MenuSpec` ⇒ `modules::ALL_MENUS`)—— - 菜单的 `f_url_address`(前端 Route path)与 `f_en_code`(面 B 点权限编码)**都是业务知识**。 - 平台层只自带 **5 条系统菜单**(`system` / `system/User` / `system/Role` / `system/Organize` / `system/Module`)。 - - 🔴 **接线在装配根** `src/backend/src/bootstrap.rs` —— 唯一同时认识两层的地方: - `bootstrap::ensure_base(db)` = `platform::seed::ensure_base(db, modules::all_menus())`。 - 应用与**测试**都走它 ⇒ 测到的库 == 上线的库。 - 🔴 **入口文件也不许写死业务表名**(`main.rs` 的 `BASE_TABLES` 只有 7 张 `base_*`; - 业务表由 `modules::all_specs()` 派生,并与 `db/schema.sql` **双向对账**)。 - - 🔴 **引擎不许按 app_code 分支**(例如 `f_creator_user_id` 的写死规则)—— - 由业务 spec 自己声明(`EntitySpec.creator_fixed`),引擎只读声明。 - - 🔴 **这把红线由尺子钉住**:`bash scripts/check-boundary.sh`(CP1–CP6)—— - CP1 扫平台层的**字符串字面量**找业务标识符(禁止清单**从业务层派生** ⇒ 加模块自动变严), - CP1' 是扫描器的**反自证**(造一个明知存在的泄漏必须被抓到)。 +12. 🔴 **平台 / 业务分离(靠仓库边界,不靠目录纪律)。** + - **平台** = 已发布的 `sspf` 包(`Cargo.toml` 的 git tag)—— **不在本仓**。 + 它自带登录 / 权限 / `base_*` / 面 B / CRUD 引擎 / 177 张表。 + - **业务** = `packs//`(真源:表 DDL + 列 + 菜单 + 面 B 路由)+ + `src/backend/src/modules/.rs`(面 A 适配器,只 `pub use` 转发 spec)。 + - **加一个业务模块只碰业务** ⇒ 平台一个字都不改(它根本不在这里)。 + 唯一接头是 `main.rs` 的 `Platform::new().packs(reg).router(modules::router())`。 + - 🔴 **业务菜单不要传给 `.menus()`**:`.packs(reg)` 已把 `PackRegistry.menus` 带进种子, + 给两次会在种子里撞主键。 + - 🔴 **不许把平台抄回来**:出现 `platform/` / `routes.rs` / `crates/` / `base_*` 建表语句 + ⇒ `check-scaffold.py` 的 SC1/SC2 红。这是本仓最重要的一条判据 —— + 抄回来不会报错,只会让平台再也升不动。 + - 🔴 **引擎不许按 app_code 分支**:业务差异由 spec 声明(`EntitySpec.creator_fixed`)。 + 13. 🔴 **生产档弱口令守卫(`SSW_PROFILE=prod` 才生效)。** - 六条判据:① 键不在本部署清单里 ⇒ 跳过 ② 空/空白 ③ 精确等于已知弱值 ④ **含**已知弱值(反绕过)⑤ 命中弱标记词(**整体词**,`administrator` 不误伤)⑥ 长度 < 12。 @@ -258,12 +231,12 @@ ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · 17. **菜单的 `f_url_address` 与 `f_en_code` 必须一字不差地一致**: `MenuSpec.url_address` == `EntitySpec.module_key` == 前端 ``(去前导斜杠)—— 三者任一不一致 ⇒ 菜单显示了但守卫不命中(或反过来)⇒ **静默**失败。 - `modules/mod.rs` 的 `menu_url_matches_module_key` 单测钉住前两者; - `scripts/check-module.sh` 的第 10 个接触点钉住第三个。 -18. **加一个业务模块 = 三处登记**(全在业务层): - `modules/.rs` 声明 `EntitySpec` + `*_MENU: MenuSpec` + `ROUTES`; - `modules/mod.rs` 的 `ALL_SPECS` / `ALL_MENUS` / `ALL_ROUTES` 各加一条; - `db/schema.sql` 加建表。**平台层与入口文件一个字都不用改。** + `modules/mod.rs` 的单测钉住前两者;`perm-smoke.sh` 的菜单断言钉住实际树形状。 +18. **加一个业务模块 = 一条命令**: + `bash scripts/new-pack.sh --name "中文名" --columns "a:VARCHAR(200)"` + ⇒ 建 `packs//`(表 + 列 + 菜单 + 面 B 路由)+ `modules/.rs`(面 A), + 并自动补齐 `packs_gen.rs` / `modules/mod.rs` 五段 / `Cargo.toml` 的 `GEN:PACK_DEPS`。 + **平台一个字都不用改**(它不在本仓)。手改生成段 ⇒ `pack-sync.py --check` 红。 ## 数据模型 @@ -300,15 +273,15 @@ ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · **不支持** `{a,b}` 这种「一段里多个参数」的写法 ⇒ 必须逐条注册)。 其中 **27 条 = 面 A**(ssw 形状,**冻结**)、**5 条 = 面 B**(官方 JNPF 形状,新增)。 -🔴 **面 A 的 9 条业务路由不在 `routes.rs` 里** —— 它们由**业务层自带** -(`src/backend/src/modules/.rs` 的 `router()`),`routes.rs` 只 -`.merge(modules::router())` 一次 ⇒ **加业务模块不动平台层**。 -(本表逐字照旧;只是「注册位置」在业务层。) +🔴 **面 A 的 12 条业务路由不在平台里** —— 它们由**业务层自带** +(`src/backend/src/modules/.rs` 的 `router()`),`main.rs` 只 +`.router(modules::router())` 一次 ⇒ **加业务模块不动平台**。 +(本表逐字照旧;「注册位置」在业务层。) 🔴 **机器可读版在 `docs/contract.md` 附录 A 的 `[ENDPOINT]` 区段**(一行一条端点: -`face` / `method` / `path` / `guard` / `owner`,共 32 行)⇒ -`bash scripts/check-contract.sh` 把它与**代码里真实注册的路由**逐条对账 -(总数 / 方法 / 归属层 / 守卫,双向)⇒ **本表与代码漂移立刻报**。 +`face` / `method` / `path` / `guard` / `owner`)。平台搬走后**本仓不再做静态路由对账** +(那些路由在 `sspf` 里,静态扫描器看不进来)⇒ 改由两把**运行时**尺子打真实 HTTP 验证 +(`perm-smoke.sh` / `perm-smoke-jnpf.sh`)——比静态对账更硬,但要求服务能起。 📊 **官方端点台账**在同一份附录 A 的 `[OFFICIAL]` 区段(53 行: `method` / `path` / `status` / `src` / `note`)⇒ 记的是**本仓对官方 JNPF 契约面的覆盖** @@ -358,42 +331,35 @@ ssw-jnpf-lite-rust/ # 【仓根 = 技能根】三处软链 ~/.agents · ## 命令速查 ```bash -# 编译(仓库根是 cargo workspace,成员 = src/backend) +# 编译(仓库根是 cargo workspace,成员 = src/backend + packs/*) cargo build # debug cargo build --release # 发布版(release profile 写在根 Cargo.toml) -cargo test # 单测 +cargo test --workspace # 全量测试 # 工程脚本(仓库根 run.sh;退出码 0 成功 / 1 运行期失败 / 2 用法错) bash run.sh install # cargo fetch + npm --prefix src/frontend install bash run.sh build # cargo build --release + vite build bash run.sh dev # 后台起后端(30010) + 前端(5173),日志 .logs/、PID .run/ -bash run.sh backend # 前台起后端 -bash run.sh frontend # 前台起前端 -bash run.sh stop # 停后台进程(幂等) -bash run.sh logs # tail .logs/{backend,frontend}.log -bash run.sh # 无参 ⇒ 用法错 ⇒ 退出码 2 +bash run.sh backend / frontend / stop / logs # 运行(后端) PORT=30010 ./target/release/ssw-jnpf-lite-rust -PGLITE_DIR=memory:// PORT=30010 ./target/release/ssw-jnpf-lite-rust # 临时库(系统临时目录的一次性数据目录,进程退出即销毁;pglite-rs 0.2.7 没有真内存模式) -SSW_PROFILE=prod SEED_ADMIN_PASSWORD='<强口令>' PORT=30010 ./target/release/ssw-jnpf-lite-rust # 生产档:弱口令 ⇒ 拒绝启动 +PGLITE_DIR=memory:// PORT=30010 ./target/release/ssw-jnpf-lite-rust # 临时库(一次性数据目录) +SSW_PROFILE=prod SEED_ADMIN_PASSWORD='<强口令>' PORT=30010 ./target/release/ssw-jnpf-lite-rust -# 前端 -npm --prefix src/frontend install # 或 npm ci(严格按 package-lock.json 装) -npm --prefix src/frontend run build # 产出 src/frontend/dist -npm --prefix src/frontend run dev # http://127.0.0.1:5173(vite 代理 /api → 30010) - -# 冒烟 / 自检 -bash scripts/perm-smoke.sh # 面 A:32 条断言(**后端不用先起** ⇒ 不通则自起隔离实例) -B=http://127.0.0.1:30010 bash scripts/perm-smoke.sh # 显式指定 B ⇒ 不自起(不可达 ⇒ 退出码 2) -bash scripts/perm-smoke-jnpf.sh # 面 B:官方 JNPF 形状(18 条断言;未落地记 SKIP) -bash scripts/check-module.sh # 10 接触点静态自检(93 条,纯静态,不起后端) -bash scripts/check-boundary.sh # 分层红线自检 CP1–CP6(11 条,纯静态,只需 python3) -bash scripts/check-contract.sh # 契约端点表 ↔ 代码真实路由 对账 CC2–CC10(10 条,纯静态) -bash scripts/check-citations.sh # 文档引文 `路径:行号` 核对 CIT1–CIT3(4 条,纯静态) -bash scripts/reap-ipc-leaks.sh # 回收 macOS 上泄漏的 SysV 信号量(cargo test 跑多了会攒) -python3 scripts/contract_expect.py dump # 打印契约附录 A 的全部机器可读期望值(尺子的唯一期望源) -./target/release/ssw-jnpf-lite-rust --enc 123456 # cipher 自证(免 node 依赖) +# 判据(一键 / 分项) +bash scripts/verify.sh # 全量 7 步 +bash scripts/verify.sh --fast # 静态 + 测试 4 步 +python3 scripts/check-scaffold.py # SC1–SC6:本仓只准有业务 +python3 scripts/check-scaffold.py --self-test # 反自证 6/6 +python3 scripts/pack-sync.py --check # 生成物漂移 +bash scripts/new-pack.sh blog Post --name "文章" --columns "title:VARCHAR(255)" +bash scripts/perm-smoke.sh # 面 A:32 条(后端不用先起,自起隔离实例) +B=http://127.0.0.1:30010 bash scripts/perm-smoke.sh # 显式指定 B ⇒ 不自起 +bash scripts/perm-smoke-jnpf.sh # 面 B:18 条 +bash scripts/reap-ipc-leaks.sh # 回收 macOS 泄漏的 SysV 信号量 +python3 scripts/contract_expect.py dump # 打印契约附录 A 的全部期望值 +./target/release/ssw-jnpf-lite-rust --enc 123456 # cipher 自证(免 node) ``` > 本机 curl 走系统代理,**测 localhost 必须加 `--noproxy '*'`**。 diff --git a/Cargo.lock b/Cargo.lock index fab103d..ebb0e74 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1067,20 +1067,315 @@ dependencies = [ ] [[package]] -name = "ssw-jnpf-lite-rust" +name = "sspf" +version = "0.4.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "libc", + "sspf-contract", + "sspf-core", + "sspf-mcp", + "sspf-plugin", + "sspf-sdk", + "sspf-store", + "ssw-platform", + "tokio", +] + +[[package]] +name = "sspf-compat-core" version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "serde", + "serde_json", + "sspf-contract", + "sspf-core", +] + +[[package]] +name = "sspf-compat-ext" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "chrono", + "serde", + "serde_json", + "sspf-compat-core", + "sspf-compat-msg", + "sspf-compat-system", + "sspf-contract", + "sspf-core", +] + +[[package]] +name = "sspf-compat-msg" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "chrono", + "serde", + "serde_json", + "sspf-compat-core", + "sspf-contract", + "sspf-core", +] + +[[package]] +name = "sspf-compat-onlinedev" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "serde", + "serde_json", + "sspf-compat-core", + "sspf-contract", + "sspf-core", +] + +[[package]] +name = "sspf-compat-permission" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "chrono", + "serde", + "serde_json", + "sspf-compat-core", + "sspf-compat-system", + "sspf-contract", + "sspf-core", + "sspf-store", +] + +[[package]] +name = "sspf-compat-system" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "chrono", + "serde", + "serde_json", + "sspf-compat-core", + "sspf-contract", + "sspf-core", + "sspf-store", +] + +[[package]] +name = "sspf-compat-workflow" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" dependencies = [ "aes", "axum", "chrono", "ecb", "hex", + "serde", + "serde_json", + "sspf-compat-core", + "sspf-contract", + "sspf-core", +] + +[[package]] +name = "sspf-contract" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "http", + "serde", + "serde_json", + "uuid", +] + +[[package]] +name = "sspf-core" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "aes", + "axum", + "chrono", + "ecb", + "hex", + "libc", + "md-5 0.10.6", + "rand 0.8.8", + "serde", + "serde_json", + "serde_urlencoded", + "sspf-contract", + "sspf-store", + "tokio", +] + +[[package]] +name = "sspf-lowcode" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "serde", + "serde_json", + "sspf-contract", +] + +[[package]] +name = "sspf-lowcode-exec" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "chrono", + "pglite-rs", + "serde_json", + "sspf-core", + "sspf-lowcode", + "sspf-mcp", + "sspf-store", +] + +[[package]] +name = "sspf-mcp" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "serde", + "serde_json", + "sspf-contract", + "tokio", +] + +[[package]] +name = "sspf-mcp-adapter" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "axum", + "pglite-rs", + "serde_json", + "serde_urlencoded", + "sspf-compat-onlinedev", + "sspf-compat-permission", + "sspf-compat-system", + "sspf-compat-workflow", + "sspf-core", + "sspf-lowcode", + "sspf-lowcode-exec", + "sspf-mcp", +] + +[[package]] +name = "sspf-pack-asset" +version = "0.2.0" +dependencies = [ + "sspf", +] + +[[package]] +name = "sspf-pack-books" +version = "0.2.0" +dependencies = [ + "sspf", +] + +[[package]] +name = "sspf-pack-demo" +version = "0.2.0" +dependencies = [ + "sspf", +] + +[[package]] +name = "sspf-pack-shop" +version = "0.2.0" +dependencies = [ + "sspf", +] + +[[package]] +name = "sspf-plugin" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "serde", + "serde_json", + "sspf-contract", + "sspf-sdk", +] + +[[package]] +name = "sspf-sdk" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "sspf-contract", +] + +[[package]] +name = "sspf-store" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "chrono", + "pglite-rs", + "serde", + "serde_json", + "tokio", +] + +[[package]] +name = "ssw-jnpf-lite-rust" +version = "0.2.0" +dependencies = [ + "axum", + "sspf", + "sspf-pack-asset", + "sspf-pack-books", + "sspf-pack-demo", + "sspf-pack-shop", + "tokio", +] + +[[package]] +name = "ssw-platform" +version = "0.1.0" +source = "git+http://127.0.0.1:13300/ssw/ssw-platform.git?tag=v0.4.0#ff34ca50c107da22628127918b54370a987b2787" +dependencies = [ + "aes", + "axum", + "chrono", + "ecb", + "hex", + "libc", "md-5 0.10.6", "pglite-rs", "rand 0.8.8", "serde", "serde_json", "serde_urlencoded", + "sspf-compat-core", + "sspf-compat-ext", + "sspf-compat-msg", + "sspf-compat-onlinedev", + "sspf-compat-permission", + "sspf-compat-system", + "sspf-compat-workflow", + "sspf-contract", + "sspf-core", + "sspf-lowcode", + "sspf-lowcode-exec", + "sspf-mcp", + "sspf-mcp-adapter", + "sspf-plugin", + "sspf-store", "tokio", "uuid", ] diff --git a/Cargo.toml b/Cargo.toml index 0d7edda..5db6d10 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,48 +1,37 @@ # ssw-jnpf-lite-rust —— cargo workspace 根 # -# 🔴 **本文件是脚手架的一部分,复制到项目根时必须一起带上** +# 🔴 **平台不在本仓**(2026-11-04 改造): +# 平台能力(登录 / 权限 / 面 A·B / 低代码 / MCP / 177 张 base_* 表)来自 +# **已发布的 `sspf` 包**(git tag `v0.4.0`),不是本仓自己实现的一份。 +# 本仓只留:**示例业务包(`packs/*`)+ 面 A 适配器(`src/backend/src/modules`) +# + 薄装配入口(`src/backend/src/main.rs`)+ 前端产物**。 # -# 为什么必须有它:`src/backend/Cargo.toml` 里的 -# `version.workspace = true` / `edition.workspace = true` / `xxx = { workspace = true }` -# 都要求**上层有一个 workspace 根**。缺了它,cargo 直接报 -# `error: could not find Cargo.toml in ... or any parent directory`, -# 脚手架**根本编译不起来**。 +# 🔴 **依赖只有一个来源**:`[workspace.dependencies] sspf`,成员 crate 一律 +# `sspf = { workspace = true }`。要升平台版本 ⇒ **只改这一行**(升 tag), +# 不许在任何成员里写第二份 git/path 依赖。 # -# 这里只放「跨成员共享」的配置:成员列表、依赖版本、release profile。 -# 成员 crate(src/backend)不得再写 [profile.*],否则 cargo 直接报错。 +# 🔴 成员 crate 不得再写 `[profile.*]`(cargo 直接报错),profile 只在本文件。 [workspace] -members = ["src/backend"] +members = ["src/backend", "packs/*"] resolver = "2" [workspace.package] -version = "0.1.0" +version = "0.2.0" edition = "2021" -# pglite-rs 0.2.7 要求 Rust ≥ 1.85(edition 2024 家族)。本机实测 rustc 1.95.0。 +# pglite-rs 0.2.7 要求 Rust ≥ 1.85(edition 2024 家族)。 rust-version = "1.85" -# 依赖版本集中在此,成员 crate 一律用 `xxx = { workspace = true }` 继承。 -# -# ⚠️ 版本锁死说明(不要随意升级): -# - aes 0.8 + ecb 0.1 属于 cipher **0.4** 家族;aes 0.9 / ecb 0.2 是 cipher 0.5, -# 泛型不通用,混用编译不过。 -# - md-5 0.10 的 crate 名是 `md5`(`use md5::{Digest, Md5};`)。 -# - pglite-rs 0.2 的 **lib 名是 `pglite`**(`use pglite::PGlite;`), -# 且 0.2.7 没有 `memory://` 模式,`PGlite::open()` 只接受路径。 [workspace.dependencies] +# 🔴 **平台包**:业务仓 / 技能仓唯一该依赖的东西。 +# 升版本 = 改这个 tag(平台仓 `git tag` 已发布的那一个)。 +sspf = { git = "http://127.0.0.1:13300/ssw/ssw-platform.git", tag = "v0.4.0" } + +# 🔴 业务侧还需要的东西(平台不替我们决定 web 框架的版本) axum = "0.8" tokio = { version = "1", features = ["full"] } serde = { version = "1", features = ["derive"] } serde_json = "1" -serde_urlencoded = "0.7" -aes = "0.8" -ecb = "0.1" -md-5 = "0.10" -rand = "0.8" -uuid = { version = "1", features = ["v4"] } -hex = "0.4" -pglite-rs = "0.2" -chrono = "0.4" [profile.release] opt-level = 2 @@ -52,3 +41,7 @@ strip = "symbols" # 而 abort 下 `catch_unwind` 抓不到 panic(进程直接死 ⇒ 客户端连接重置)。 # catch-all 中间件依赖默认的 `panic = "unwind"`(Ruling P19)。 codegen-units = 16 + +[profile.dev] +# 🔴 workspace 根必须关增量:member 才进 sccache,`target/debug/incremental` 也不暴涨。 +incremental = false diff --git a/HANDOFF.md b/HANDOFF.md index b198433..c4d32b9 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -5,6 +5,73 @@ --- +## 0. 2026-11-04 第二批:技能仓改为「依赖已发布的 sspf 包」(**本次**) + +> 上一批(平台仓 `ssw-platform`)把示例搬出去并发布 `v0.4.0`;本批把**技能仓**改成消费者。 + +**做了什么** + +1. **删除自研平台**:`src/backend/src/platform/`(17 文件)、`routes.rs`(35K)、 + `bootstrap.rs`、`db/schema.sql`、`tests/`(7 个集成测试,测的是被删的那份实现)。 + 备份在 `/tmp/skill-backup/backend-2216/`。 +2. **平台改为依赖已发布包**:根 `Cargo.toml` 的 + `[workspace.dependencies] sspf = { git = ".../ssw-platform.git", tag = "v0.4.0" }`, + 成员一律 `sspf = { workspace = true }`。解析结果: + `sspf v0.4.0 (...?tag=v0.4.0#ff34ca50)`,**0 个 `sspf-pack-*` 被平台带进来**。 +3. **示例业务包迁入**:`packs/{demo,shop,books,asset}/`(表 DDL + 列 + 菜单 + 面 B 路由), + 依赖从 `sspf-sdk` 改为门面 `sspf`;`use sspf_sdk::…` → `use sspf::…`。 +4. **应用瘦成薄壳**(`src/backend/` 从 ~4000 行降到 ~500 行): + - `main.rs`:`--enc` / `--help` + `Platform::new().config().packs().router().static_dir().serve()`; + - `lib.rs`:`pub mod modules; pub mod packs_gen;`; + - `packs_gen.rs`:4 个 `load_static` + manifest 快照(生成物); + - `modules/`:4 个面 A 适配器(spec 只 `pub use` 转发)。 +5. **脚本重构**: + - 新增 `check-scaffold.py`(SC1–SC6「本仓只准有业务」+ `--self-test` 6/6); + - 新增 `pack-sync.py`(重写:4 处派生位置,`--check` 防漂移); + - 新增 `new-pack.sh` / `new-pack.py`(造包脚手架,端到端验证过); + - 新增 `verify.sh`(一键 7 步 / `--fast` 4 步); + - **删除** `check-module.sh` / `check-boundary{,-scan}` / `check-contract{,-scan}` / `check-citations{,-scan}`: + 它们测的是**本仓那份平台实现**(分层 / 契约对账 / 引文),平台搬走后没有测量对象 ⇒ 留着就是假绿。 +6. **契约同步**:`docs/contract.md` 补入 `asset` 包 —— `[MENU]` +1、`[MENU_TREE]` → 9 菜单 + (`…|图书超市:|数据资源:`)、`[MODULE]` +1、`[ENDPOINT]` +3(面 A)、`[FACE]` A 25 → 28。 + §8.4 的「值住在哪」改为「平台在 `sspf`,业务在 `packs//`」。 +7. **文档**:`SKILL.md` / `README.md` / `CLAUDE.md` / `HOWTO_MODULE.md` / `docs/runbook.md` + 全部按新架构重写关键章节(「自包含」→「依赖已发布包 + 锁 tag」;「六道闸门」→「两类判据」)。 + +**验收(全部实际跑过)** + +| 项 | 结果 | +|---|---| +| `cargo check --workspace` / `cargo build --release` | ✅ 通过(首次拉 git 依赖,之后走 `~/.cargo/git` 缓存) | +| `cargo test --workspace` | ✅ 全绿(4 个包各自 14/14/3/3 条包自检 + 应用单测) | +| `python3 scripts/check-scaffold.py` | ✅ PASS=6 FAIL=0 | +| `python3 scripts/check-scaffold.py --self-test` | ✅ 反自证 6/6 | +| `python3 scripts/pack-sync.py --check` | ✅ 4 个包 / 4 个模块,无漂移 | +| `bash scripts/perm-smoke.sh` | ✅ **PASS=32 FAIL=0** | +| `bash scripts/perm-smoke-jnpf.sh` | ✅ **PASS=18 FAIL=0 SKIP=0**(覆盖 18/18) | +| `new-pack.sh probe Widget` 端到端 | ✅ 生成 → 编译 → 起服务 → 面 A `600` / 面 B `602` / 表数 182(177 + 5)→ 删包 | + +**踩过 / 别踩** + +- 🔴 **`pack-sync.py` 的 `ROOT` 不能用脚本自身路径**:反自证在临时树里跑时, + 它会把「真实仓库」当成目标 ⇒ SC6 自证**假绿**。已加 `PACK_SYNC_ROOT` 环境变量。 +- 🔴 **生成段不能只放「数组元素」**:`replace_region` 会把 `pub const … = &[` 连同 `];` 一起盖掉 + ⇒ 语法错。正确做法是生成器输出**完整声明块**。 +- 🔴 **业务菜单不要传给 `.menus()`**:`.packs(reg)` 已经把 `PackRegistry.menus` 带进种子, + 给两次会在种子 INSERT 撞主键。 +- 🔴 **`resolve_project_dir` 找不到本仓**:平台默认锚点是 `src/backend/db/schema.sql`(本仓已删) + ⇒ `main.rs` 自己按 `SSW_PROJECT_DIR` → `Cargo.toml` + `packs/` 向上找 → cwd。 +- 🔴 **加了 `asset` 包 ⇒ 菜单树从 8 变 9**,`[MENU_TREE]` 不改 ⇒ 面 A 尺子当场红(它是对的)。 + +**第二批遗留(可选)** + +- `MIGRATION.md` / `JNPF_COMPAT_SURFACE.md` / `JNPF_SOURCE_AUDIT.md` 是**历史技术报告**, + 其中引用的 `src/backend/src/platform/*` 路径已不存在 —— 需要时按 `sspf` 包的模块对位, + 不必逐条改(它们描述的是行为规格,不是本仓结构)。 +- 前端 `src/frontend/dist/` 目前 gitignore;若要「开箱即用」,可把构建产物一起提交。 + +--- + ## 0. 当前状态 **v1 已完成 + v1.1 双面后端(面 B)已落地,验收全绿**(每一条 ✅ 都有实际执行输出,见 §9 与各任务报告)。 diff --git a/HOWTO_MODULE.md b/HOWTO_MODULE.md index 81a674a..06897e6 100644 --- a/HOWTO_MODULE.md +++ b/HOWTO_MODULE.md @@ -1,429 +1,211 @@ # 加一个业务模块(AI 开发主线) -本文件是 **Rust 版**的操作手册。参照实现 = 内置的三个模块 -(`demo/DemoItem` · `shop/Product` · `books/Book`)——**照抄一个最接近的,别从零想**。 - +> 🔴 **2026-11-04 起流程变了**:平台不在本仓(在已发布的 `sspf` 包里), +> 「加模块」= **写一个业务包 + 一个面 A 适配器**,其余四处派生位置**由脚本生成**。 +> 上一版的「8 个文件 / 10 个接触点 / 手改 `db/schema.sql`」已经作废 —— +> 那些位置现在都是 `// >>>GEN:xxx` 生成段,手改会被覆盖且 `--check` 会红。 +> > 契约红线见 [`SKILL.md`](SKILL.md) §「契约红线」。**本文件只讲「改哪儿、怎么验证」。** -## 〇.5、一图看完全流程(先看一遍再动) +## 〇、一张图 ``` - 1. db/schema.sql 建表(f_ 前缀 + f_id VARCHAR(50) + 软删列) - 2. src/modules/.rs 【新文件】spec + *MENU + 3 个 handler + 自己的 router() - 3. src/modules/mod.rs 加 spec 进 ALL_SPECS + 加菜单进 ALL_MENUS + 加 router() 进 merge + 加路由进 ALL_ROUTES - 4. frontend/src/api/.ts 3 个函数(list/save/delete) - 5. frontend/src/views/.tsx 列表页 - 6. frontend/src/App.tsx - 7. docs/contract.md 附录 A 加五行:[MODULE] 一行 + [MENU] 一行 + [ENDPOINT] 三行 - (本模块的 3 条端点)+ [FACE] 的 A 条数 +3 - ★ 期望值真源 - ⇒ bash scripts/check-module.sh 必须全 ✅ - ⇒ bash scripts/check-contract.sh 必须全 ✅(端点表 ↔ 代码) - 8. scripts/perm-smoke.sh 追加该模块的断言(别新写脚本) +packs// ← 业务真源(你写的) + Cargo.toml 只依赖 sspf 门面 + pack.toml 清单:app_code / 表 / 契约版本区间 + schema/001_init.sql 建表(跟着包走,include_str! 进二进制) + src/lib.rs 列 + spec + 菜单 + 面 B 路由 + Pack 实现 + +src/backend/src/modules/.rs ← 面 A 适配器(你写的,或脚本生成后微调) + 3 个 handler + ROUTES + router() + spec / 菜单只 pub use 转发(不许重写第二份) + + ↓ python3 scripts/pack-sync.py(生成,别手改) + +src/backend/src/packs_gen.rs ← 装载调用 + pack.toml 的 JSON 快照 +src/backend/src/modules/mod.rs ← MODS / SPECS / ROUTES / MENUS / ROUTER 五段 +src/backend/Cargo.toml ← # >>>GEN:PACK_DEPS(包的 path 依赖) + + ↓ ssfp::Platform::new().packs(reg).router(modules::router()).serve() + +面 A /api/ssw///… ← 前端在用 +面 B /api// ← 官方 JNPF 形状 ``` -**8 个文件 = 上面的 1–8**(其中 `modules/.rs` 与 `modules/mod.rs` 是**业务层**)。 -第 7 步漏了 ⇒ `check-module.sh` 直接判「契约 [MODULE] 里没有这个模块」退出 2; -`[ENDPOINT]` 漏了 ⇒ `check-contract.sh` 判「代码里的路由没被契约登记」红。 +## 一、生成一个包(一条命令) -🔴 **平台层(`src/platform/`)与入口文件(`src/backend/src/main.rs`)一个字都不用改** —— -加业务模块**不碰平台层**。 -(对比 react 版要动 4 个后端文件;本仓**只动 `src/modules/` 下的 2 个文件** + `db/schema.sql`。) -🔴 **内置菜单也住在业务层**(`modules/.rs` 的 `*_MENU: MenuSpec`)⇒ 由装配根 -`bootstrap.rs` 注入平台层的种子 ⇒ 平台层只自带 5 条**系统**菜单。 -🔴 这条分层由尺子钉住:`bash scripts/check-boundary.sh`(CP1–CP6)—— -平台层出现任何业务标识符(表名 / 实体名 / 路由前缀 / 菜单 id / url / en_code)⇒ 红。 +```bash +bash scripts/new-pack.sh blog Post --name "文章" \ + --columns "title:VARCHAR(255),body:TEXT,pv:INTEGER" +``` -## 〇、命名约定(先想清楚再动) +它会: -| 位置 | 约定 | 例(`books` / `Book`) | +1. 建 `packs/blog/{Cargo.toml,pack.toml,schema/001_init.sql,src/lib.rs}`(表名 `blog_post`); +2. 建 `src/backend/src/modules/blog.rs`(面 A 适配器,3 条路由); +3. 跑 `pack-sync.py` 把四处生成位置补齐。 + +然后: + +```bash +cargo check # 编译 +bash scripts/verify.sh # 静态判据 + 全量测试 + 两把运行时尺子 +``` + +> 🔴 **不写 `--columns` 也能跑**:只生成 `f_id` + 创建人/时间四列,之后手工补。 +> 🔴 **列类型**用 SQL 类型(`VARCHAR(255)` / `NUMERIC(12,2)` / `INTEGER` / `TIMESTAMP(0)`); +> `NUMERIC` / `DECIMAL` 会自动进 `numeric_columns`(响应序列化成 JSON **字符串** `"9.90"`)。 + +## 二、命名约定(先想清楚) + +| 东西 | 约定 | 例 | |---|---|---| -| `app_code` | 小写业务名,**同时是 URL 段** | `books` | -| `entity` | 大驼峰,**同时是 URL 段** | `Book` | -| 表名 | 蛇形,**官方没有对应表** ⇒ 自己起(推荐 `{app}_{entity 小写}`) | `book_shop_book` | -| 前端 api 文件 | entity 小写 | `src/api/book.ts` | -| 前端 view 文件 | entity 大驼峰 | `src/views/Book.tsx` | -| Route path | **= 菜单 `url_address`**(去前导斜杠) | `books/Book` | -| 菜单种子 id | `m_` + entity 小写 | `m_book` | -| 列表函数名 | `list` + 复数(复数规则见 `check-module.sh` 的 `plural()`) | `listBooks` | -| 单条函数名 | `save` / `delete` + entity | `saveBook` / `deleteBook` | +| `app_code` | 小写、与 `packs//` 目录名**逐字一致** | `blog` | +| 实体 | UpperCamelCase | `Post` | +| 表名 | `_` | `blog_post` | +| 列 | `f_` 前缀 + snake_case | `f_title` | +| JSON 键 | 去 `f_` 前缀后 camelCase | `title` | +| 菜单 `id` | `m_` | `m_blog` | +| 菜单 `url_address` | `/` | `blog/Post` | +| spec 的 `module_key` | **必须等于** `url_address`(也等于前端 Route path) | `blog/Post` | -🔴 **表名不与官方对齐是刻意的**(官方没有低代码业务表)——但**两版后端(react 版 / rust 版)之间要同名**, -才能开同一个库。`demo_item` / `shop_product` / `book_shop_book` 就是这么定的。 +🔴 `module_key != url_address` 的后果是**静默放行**(菜单查不到 ⇒ 权限守卫直接放行)。 -## 一、要碰的 8 个文件(10 个接触点) +## 三、包里的四个文件 -| # | 文件 | 改什么 | 漏了会怎样 | -|---|---|---|---| -| 1 | `src/backend/db/schema.sql` | `CREATE TABLE {table}` | 端点 500(表不存在) | -| 2 | `src/backend/src/modules/.rs` | **新文件**:spec + `*_MENU` + 3 个 handler + `router()` | 端点 404(没注册)/ **菜单不显示** | -| 3 | `src/backend/src/modules/mod.rs` | `ALL_SPECS` 加一条 + `ALL_MENUS` 加一条 + `router()` merge 一行 + `ALL_ROUTES` 加 3 条 | 启动自检失败 / 端点 404 / **菜单不被种、admin 少一条授权** | -| 4 | `src/frontend/src/api/.ts` | 3 个函数 | 页面发请求 404 | -| 5 | `src/frontend/src/views/.tsx` | 列表页 | 页面空白 | -| 6 | `src/frontend/src/App.tsx` | `` | **页面 404** | -| 7 | `docs/contract.md` | **附录 A**:`[MODULE]` 加一行 + `[MENU]` 加一行 + `[ENDPOINT]` 加 3 行(本模块的 3 条端点)+ `[FACE]` 的 A 条数 +3(期望值真源) | 自检退出码 2(闸门形同虚设)/ `check-contract.sh` 红 | -| 8 | `scripts/perm-smoke.sh` | 追加该模块的断言 | 新模块无端到端覆盖 | +### 3.1 `pack.toml` -**外加两条一致性**: -1. `spec.module_key` == `menu.url_address` == `App.tsx` 的 Route path —— **三处一字不差**。 - 不一致的后果是**静默放行**(未映射到菜单就放行,不报错)。 -2. 🔴 **入口文件也不碰**:`main.rs` 的 `BASE_TABLES` 只列 7 张 `base_*`, - 业务表由 `modules::all_specs()` 派生并与 `db/schema.sql` 双向对账 - ⇒ 加业务表**不用**改 `main.rs`。 +```toml +[pack] +app_code = "blog" +name = "文章" +version = "1.0.0" +kernel = ">=0.4,<0.5" # 契约版本区间(业务包要求的平台契约版本) +migratable = true -🔴 **分层铁律**:后端代码分两层—— +[[pack.tables]] +name = "blog_post" +ddl = "schema/001_init.sql" +baseline_table = "blog_post" +``` -| 层 | 目录 | 内容 | 加模块时 | -|---|---|---|---| -| **平台层** | `src/backend/src/platform/` | 契约实现(信封 / cipher / 登录 / 权限 / `base_*` 管理 / 面 B / CRUD 引擎) | **一个字都不改** | -| **业务层** | `src/backend/src/modules/` | 业务 spec + **业务菜单** + handler + 路由 | **只改这里** | -| **装配根** | `src/backend/src/bootstrap.rs` | 唯一同时认识两层的地方 | **一个字都不改** | +🔴 `kernel` 不是 cargo 版本,是 `sspf::kernel::bootstrap::kernel_version()` 那个**契约版本** +(当前 `0.4.0`);写错区间 ⇒ 装载直接报 `LoadError::KernelMismatch`。 -(对齐 react 版的 `common`+`auth`+`sys` / `demo`+`shop`+`books`, -以及官方 JNPF 的 `jnpf-common`+`jnpf-system` / `jnpf-admin`。) - -## 二、后端四处改什么 - -### 2.1 `db/schema.sql` —— 建表 - -照抄 `book_shop_book` 的形状: +### 3.2 `schema/001_init.sql` ```sql -CREATE TABLE {table} ( +CREATE TABLE IF NOT EXISTS blog_post ( f_id VARCHAR(50) NOT NULL, - f_title VARCHAR(200), - f_price NUMERIC(12,2), - f_stock INT, + f_title VARCHAR(255), f_creator_user_id VARCHAR(50), - f_creator_time TIMESTAMP, - f_delete_mark INT DEFAULT 0, - CONSTRAINT pk_{table} PRIMARY KEY (f_id) + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_mark INTEGER DEFAULT 0, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) ); ``` -红线: -- 列名**全部 `f_` 前缀**;主键 `f_id VARCHAR(50)`(**不是 32**——36 位 UUID 装不下)。 -- 软删列 `f_delete_mark INT DEFAULT 0`(**不是**物理 DELETE)。 -- 🔴 **numeric 列(金额)** ⇒ spec 里要标 `numeric: true`(投影 `::text` ⇒ JSON 字符串 `"9.90"`)。 -- 🔴 **改了 schema.sql 不生效**:schema 只在**首次**建表时执行 ⇒ 改完要**清空 `data/` 重建**。 +🔴 **必须幂等**(`IF NOT EXISTS`):启动时每次都会跑一遍。 +🔴 **必须带 `f_tenant_id` 并进复合主键**:装载器有硬闸门(`pack_ddls_carry_tenant_id_and_composite_key`)。 +🔴 **不许建 `base_*`**:平台表归 `sspf` 管,装载器会拒载。 +🔴 **spec 的列清单里不要写 `f_tenant_id`** ⇒ 面 A / 面 B 的 JSON 形状不受它影响。 -### 2.2 `src/modules/.rs` —— 【新文件】spec + handler + 路由 +### 3.3 `src/lib.rs` -**照抄 `src/backend/src/modules/shop.rs`**(最接近的参照实现)。一个文件三块: +四样东西,顺序固定: + +1. `DDLS: &[(&str, &str)]` —— `表名 → include_str!` 的 DDL; +2. `*_SPEC: EntitySpec` —— `app_code` / `entity` / `table` / `module_key` / `columns` / `numeric_columns`; +3. `*_MENU: MenuSpec` —— 内置菜单(`url_address` 必须 == `module_key`); +4. `*_ROUTES: &[PackRoute]`(**面 B**,官方 RESTful 形状)+ `impl BusinessPack for Pack`。 + +🔴 **类型名固定 `Pack`**:`packs_gen.rs` 按 `sspf_pack_::Pack` 拼路径。 +🔴 **每条实体恰好 3 条路由**(List / Save / Delete)—— 装载自检钉住这个数。 +🔴 **面 B 是声明不是 handler**:`PackRoute` 里没有 axum 类型 ⇒ 包不依赖 axum, + 内核按声明 + spec 生成 handler。 + +### 3.4 `src/backend/src/modules/.rs`(面 A) ```rust -//! shoes —— 业务模块:Shoe(物理表 `shoe_item`)。 +pub use sspf_pack_blog::POST_MENU; +pub use sspf_pack_blog::POST_SPEC; -use axum::body::Bytes; -use axum::extract::{RawQuery, State}; -use axum::http::HeaderMap; -use axum::routing::{delete, get, post}; -use axum::{Json, Router}; - -use crate::platform::crud::{handle_delete, handle_list, handle_save}; -use crate::platform::entity::{ColumnSpec, EntitySpec}; -use crate::platform::envelope::ActionResult; -use crate::platform::state::AppState; - -/// ① spec 的列清单(**顺序 = 响应 JSON 的键序**)。 -const SHOE_COLUMNS: &[ColumnSpec] = &[ - ColumnSpec { column: "f_id", json_key: "id", default: None, numeric: false }, - ColumnSpec { column: "f_title", json_key: "title", default: None, numeric: false }, - ColumnSpec { column: "f_price", json_key: "price", default: Some("0.00"), numeric: true }, - ColumnSpec { column: "f_creator_user_id", json_key: "creatorUserId", default: None, numeric: false }, - ColumnSpec { column: "f_creator_time", json_key: "creatorTime", default: None, numeric: false }, - ColumnSpec { column: "f_delete_mark", json_key: "deleteMark", default: Some("0"), numeric: false }, -]; - -/// ② spec 本体。 -pub const SHOE_SPEC: EntitySpec = EntitySpec { - app_code: "shoes", - entity: "Shoe", - table: "shoe_item", - module_key: Some("shoes/Shoe"), // 🔴 None ⇒ 仅登录(demo 就是 None) - columns: SHOE_COLUMNS, - numeric_columns: &["f_price"], // 🔴 必须与每列的 numeric 标记一致(有单测钉) - // 🔴 `f_creator_user_id` 的写死规则(裁决 S22): - // `Some("admin")` ⇒ 恒写 admin(demo 的规则);`None` ⇒ `body.creatorUserId || 'admin'`。 - creator_fixed: None, -}; - -/// ③ 本模块的 3 条路由(**业务层的路由表**)—— 钉子测试遍历它。 pub const ROUTES: [&str; 3] = [ - "/api/ssw/shoes/Shoe/List", - "/api/ssw/shoes/Shoe/Save", - "/api/ssw/shoes/Shoe/Delete", + "/api/ssw/blog/Post/List", + "/api/ssw/blog/Post/Save", + "/api/ssw/blog/Post/Delete", ]; - -// ---- 3 个 handler:不要重写业务逻辑 ---- -// `handle_list` / `handle_save` / `handle_delete`(平台层)已经把 -// 守卫、SQL 拼装、投影、软删、序列化全包了。 - -/// `GET /api/ssw/shoes/Shoe/List`。 -pub async fn shoe_list(State(state): State, headers: HeaderMap) -> Json { - handle_list(&state, &headers, &SHOE_SPEC).await -} - -/// `POST /api/ssw/shoes/Shoe/Save`。 -pub async fn shoe_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - handle_save(&state, &headers, &SHOE_SPEC, &body).await -} - -/// `DELETE /api/ssw/shoes/Shoe/Delete?id=`。 -pub async fn shoe_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - handle_delete(&state, &headers, &SHOE_SPEC, &raw).await -} - -/// 本模块的路由(`Router::merge` 进总路由,**对齐 NestJS 的 module 注册**)。 -pub fn router() -> Router { - Router::new() - .route(ROUTES[0], get(shoe_list)) - .route(ROUTES[1], post(shoe_save)) - .route(ROUTES[2], delete(shoe_delete)) -} ``` -🔴 **`json_key` 必须等于 `db::column_to_json_key(column)`**(`f_title` ⇒ `title`)—— 有单测钉死,不一致会红。 -🔴 **列顺序 = 响应 JSON 的键序**(照抄参照模块,别自作主张排序)。 -🔴 **`default` 只在「路径 1(无 id 的新建)」生效**——带 id 但库里没这行时,**一个默认值都不加**。 -🔴 **handler 签名不要改**:`Save` 收 `body: Bytes`(自己解析,不走 `Json`), -`Delete` 收 `raw: RawQuery`(`?id=`)—— `handle_save` / `handle_delete` 依赖这个形状。 -🔴 **spec 写成 `const`**(不是 `fn find_spec(..).expect(..)`)—— 非测试代码**零 `unwrap()` / `expect()` / `panic!()`** 是项目红线。 +三个 handler 都是三行(`handle_list` / `handle_save` / `handle_delete`), +模板见 `new-pack.sh` 生成的那份。 -### 2.3 `src/modules/mod.rs` —— 登记这个模块(3 处) +🔴 **只准 `pub use` 转发 spec**:两份 spec 拷贝迟早分叉;`pack-sync.py` +在没有 `pub use ..._SPEC` 时直接报错。 -```rust -pub mod books; -pub mod demo; -pub mod shop; // 🔴 加这一行 +## 四、改已有包(加列 / 改菜单 / 加路由) -pub const ALL_SPECS: &[EntitySpec] = &[ - demo::DEMO_SPEC, - shop::PRODUCT_SPEC, - books::BOOK_SPEC, - shoes::SHOE_SPEC, // 🔴 加这一条 -]; - -pub const ALL_ROUTES: &[&str] = &[ - demo::ROUTES[0], - demo::ROUTES[1], - demo::ROUTES[2], - shop::ROUTES[0], - shop::ROUTES[1], - shop::ROUTES[2], - books::ROUTES[0], - books::ROUTES[1], - books::ROUTES[2], - shoes::ROUTES[0], // 🔴 加这三条 - shoes::ROUTES[1], - shoes::ROUTES[2], -]; - -pub fn router() -> Router { - demo::router() - .merge(shop::router()) - .merge(books::router()) - .merge(shoes::router()) // 🔴 加这一行 -} -``` - -🔴 **`ALL_SPECS` 漏了** ⇒ 启动时的标识符白名单自检会失败(`spec 表 … 在 db/schema.sql 里没有 CREATE TABLE`)—— - 记得同时把新表加进 `src/backend/db/schema.sql`(**`main.rs` 不用改** ⇒ 业务表由 spec 派生)。 -🔴 **`ALL_MENUS` 漏了** ⇒ 菜单**不会被种**、admin **少一条授权** ⇒ 侧栏少一项。 -🔴 **`router()` 漏了 merge** ⇒ 端点 404。 -🔴 **`ALL_ROUTES` 漏了** ⇒ 路由表钉子测试**不会报错**(它只遍历这张表)⇒ 静默失去覆盖 ⇒ 一定要加。 - -### 2.4 `src/modules/.rs` —— 声明自己的内置菜单 - -🔴 **业务菜单住在业务层**(与 `EntitySpec` 同理:`f_url_address` 与 `f_en_code` **都是业务知识**)。 - -在本模块文件里加一条(与 `*_SPEC` 同级): - -```rust -use crate::platform::menu::MenuSpec; // 🔴 类型住在平台层,**值**住在业务层 - -pub const SHOE_MENU: MenuSpec = MenuSpec { - id: "m_shoe", - full_name: "鞋", - en_code: "permission.shoes.shoe", // 🔴 面 B 的点权限编码(官方 @SaCheckPermission 的判据) - url_address: "shoes/Shoe", // 🔴 必须 == Route path == spec.module_key - parent_id: "0", - menu_type: 2, // 1 = 目录,2 = 页面(官方 f_type 是 **INTEGER**) - icon: None, - sort_code: 9, -}; -``` - -再在 `src/backend/src/modules/mod.rs` 的 `ALL_MENUS` 里加一条 `shoes::SHOE_MENU,`。 - -🔴 **还要在契约里登记**(`docs/contract.md` **附录 A**): -- `[MODULE]` 加一行:`shoes Shoe shoe_item shoes/Shoe shoes/Shoe m_shoe 有 shoes.rs` -- `[MENU]` 加一行:`m_shoe 鞋 permission.shoes.shoe shoes/Shoe 0 2 9` -- `[ENDPOINT]` 加**三行**(本模块的 3 条端点,`face` 一律 `A`, - `guard` = `shoes/Shoe`(= `module_key`;仅登录的模块写 `登录`),`owner` = `shoes`): - ``` - A GET /api/ssw/shoes/Shoe/List shoes/Shoe shoes - A POST /api/ssw/shoes/Shoe/Save shoes/Shoe shoes - A DELETE /api/ssw/shoes/Shoe/Delete shoes/Shoe shoes - ``` -- `[FACE]` 的 **A 条数 +3**(面 A 专属端点多了 3 条) - -⇒ 这几行是**尺子的期望值真源**(`check-module.sh` / `check-boundary.sh` / `check-contract.sh` -都从那里读)⇒ -**代码里的 `*_MENU` 与契约那一行必须逐字一致**(`check-module.sh` 会逐字段比对); -**代码里注册的路由与 `[ENDPOINT]` 那三行必须逐条一致**(`check-contract.sh` 对账)。 - -🔴 **种子是「幂等 ensure」**:启动时按 `f_url_address` **或** `f_id` 判存在 ⇒ -**改了 `url_address` 必须重启回灌**;软删行**不复活**、不覆盖已改值。 -🔴 **改了种子要重启进程**才会回灌存量库,**不必删库重建**。 -🔴 **`en_code` 是面 B 的点权限判据**(`base_module.f_en_code`)—— 面 A 看 `f_url_address`、 - 面 B 看 `f_en_code`,**两套并存**。迁移前要补(见 `MIGRATION.md` §2.4)。 -🔴 **平台层不许出现这条菜单**(`platform/seed.rs` 只自带 5 条系统菜单)⇒ - `bash scripts/check-boundary.sh` 会红。 - -## 三、前端三文件改什么 - -### 3.1 `src/api/.ts` —— 3 个函数 - -```ts -import request from './request'; - -export const listShoes = () => request.get('/ssw/shoes/Shoe/List'); -export const saveShoe = (dto: any) => request.post('/ssw/shoes/Shoe/Save', dto); -export const deleteShoe = (id: string) => request.delete(`/ssw/shoes/Shoe/Delete?id=${id}`); -``` - -🔴 `request.ts` 的 `baseURL` 是 `/api` ⇒ 这里**不要**再写 `/api` 前缀。 -🔴 **函数名规则**:`list` + 复数(`plural()`:`s/x/ch/sh` → `+es`;辅音 + `y` → `ies`;否则 `+s`), -`save`/`delete` + entity。`check-module.sh` 按这个规则查。 - -### 3.2 `src/views/.tsx` —— 列表页 - -照抄 `views/Book.tsx`(含 numeric 往返、删除确认、错误提示)。 -🔴 **金额展示别用 `Number()` 转**——后端给的是字符串 `"9.90"`,转数字会丢尾零。 - -### 3.3 `src/App.tsx` —— 注册路由 - -```tsx -import Shoe from './views/Shoe'; -… -} /> -``` - -🔴 **Route path 必须 == 菜单 `url_address`**(去前导斜杠)—— 不一致 ⇒ 侧栏点了 404。 -🔴 JSX 常写成多行(``)⇒ `check-module.sh` 用 `tr '\n' ' '` 去换行再匹配。 - -## 四、菜单 + 授权 - -- **菜单**:**在业务模块里**声明(`modules/.rs` 的 `*_MENU`,见 2.4)⇒ 前端侧栏由 - **后端返回的菜单树**驱动 ⇒ 不用改前端导航。 -- **授权**:**默认不授权 ⇒ 非管理员看不到、访问 403**(这是对的)。 - 要让某个角色看到 ⇒ 写 `base_authorize` - (`f_object_type='role'` + `f_object_id=` + `f_item_type='module'` + `f_item_id=`)。 - 走 `PUT /api/permission/Authority/Data/{objectId}`(`objectType` **小写** `'role'`, - `module` 传**一维数组**)。 -- **admin 角色**:`platform/seed.rs` 的 `ensure_admin_authorizations` 会**自动**补 - **全部内置菜单**(5 条系统菜单 + 业务层声明的那几条)的授权 ⇒ - 管理员开箱即用,普通角色要手动授权。 - -## 五、验证(追加断言,别新写脚本) - -### 5.1 静态自检(改完立刻跑,**先于** perm-smoke) - -```bash -bash scripts/check-module.sh shoes Shoe # 单模块 -bash scripts/check-module.sh # 契约登记的全部模块 + 全局红线 -bash scripts/check-contract.sh # 契约端点表 ↔ 代码真实路由(全局) -``` - -🔴 **先在契约里登记**(§一 第 7 步)—— `docs/contract.md` **附录 A**: -`[MODULE]` 加一行(app / entity / 表名 / urlAddress / moduleKey / 菜单 id / 有无 api 文件 / 模块文件名)、 -`[MENU]` 加一行(菜单 id / 名称 / enCode / urlAddress / parentId / type / icon / sortCode)、 -`[ENDPOINT]` 加三行(本模块的 3 条端点:face / method / path / guard / owner)、 -`[FACE]` 的 A 条数 +3。 -🔴 **`check-module.sh` 里不再有期望表**(全部从契约读)⇒ 加模块**不用改脚本**, -但**必须改契约**,否则脚本判「契约 [MODULE] 里没有这个模块」退出 2。 -🔴 `check-contract.sh` 同理:代码里注册了路由而契约 `[ENDPOINT]` 没登记 ⇒ **红**。 - -### 5.2 端到端(`scripts/perm-smoke.sh` 追加断言) - -**必选 4 条**(每个业务模块都有): - -1. `GET /api/ssw/{app}/{Ent}/List` 无 token ⇒ `code=600` -2. 无 token ⇒ `code=600`(同上一条,测的是**端点在、守卫在**) -3. 非管理员未授权 ⇒ `code=403` -4. 管理员新建一条 ⇒ `code=200` + 回读列表里能看到(长度 +1) - -**每个业务字段加一条往返断言**(防 numeric/text/int 转换 bug): - -```bash -# numeric ⇒ JSON 字符串(带尾零);int ⇒ JSON 数字 -# 例:Shoe 的 f_price 回显必须等于 "9.90"(字符串),f_stock 必须等于 100(数字) -``` - -🔴 **判据要比原始 JSON 文本**——字符串 `"9.90"` 与数字 `9.9` 在 jq 里都能取到, -只有比**原始文本**才分得出来。 -🔴 **别用 `--data-urlencode` 配 `-G`**(curl 里两个互斥)——body 用 `-d`,query 用 `-G`。 -🔴 本机 curl 走系统代理 ⇒ **测 localhost 必须 `--noproxy '*'`**。 - -### 5.3 六道闸门全绿才算完 - -```bash -cargo test # 220 条 -bash scripts/check-module.sh # 静态闸门 1:10 接触点(93 条) -bash scripts/check-boundary.sh # 静态闸门 2:分层红线 CP1–CP6(11 条) -bash scripts/check-contract.sh # 静态闸门 3:契约端点表 + 官方端点台账 ↔ 代码真实路由(10 条) -bash scripts/check-citations.sh # 静态闸门 4:文档引文 `路径:行号`(4 条) -bash scripts/perm-smoke.sh # 契约尺子·面 A:32 条(**后端不用先起** ⇒ 不通则自起隔离实例) -bash scripts/perm-smoke-jnpf.sh # 契约尺子·面 B:18 条(面 A 不受影响时也应保持 18/18) -``` - -🔴 **两把尺子默认自起隔离后端**(`scripts/smoke_backend.sh`):没给 `B` ⇒ 先探 `:30010`, -通了就用它、**不通就自起隔离实例**(空闲端口 + 临时 `PGLITE_DIR`)⇒ 跑完即删、**不留脏数据**、 -两把尺子**互不污染**、**CI 可跑**;**显式给了 `B` ⇒ 不自起**(不可达 ⇒ 退出码 2)。 - -🔴 **每道闸门都会自证**:跑出来的条数必须等于契约 `[RULER]` 里登记的条数, -对不上 ⇒ **失败** ⇒ 尺子不会被人悄悄改弱。 -🔴 **加了断言就得同步契约**(`docs/contract.md` 附录 A 的 `[RULER]` 那一列), -否则闸门会红(这是**故意的**:提醒你契约与尺子必须一起改)。 -🔴 **加业务模块会让 `check-module.sh` 的条数变多**(每模块 20+ 条)⇒ -自证那一行会直接告诉你**实际条数**,照着改契约 `[RULER] check-module.sh` 即可。 -(`check-contract.sh` 的条数是**固定的 10** —— 端点多少条都由契约自己决定,不影响它; -`check-citations.sh` 的条数是**固定的 4** —— 引文多少条都是逐条核对,不影响它。) - -## 六、写之前的自查(5 条) - -1. **列名全 `f_` 前缀?** `f_id` 是 `VARCHAR(50)` 不是 `VARCHAR(32)`? -2. **`json_key` = 列名去 `f_` 后 camelCase?**(`f_creator_user_id` ⇒ `creatorUserId`) -3. **numeric 列标了 `numeric: true`?** `numeric_columns` 数组同步更新? -4. **`module_key` == `menu.url_address` == `App.tsx` 的 Route path?**(三处一字不差) -5. **改了 `schema.sql` 之后清空 `data/` 重建了吗?**(schema 只在首次建表时执行) - -## 七、常见坑速查 - -| 症状 | 根因 | 处理 | +| 改什么 | 改哪里 | 之后 | |---|---|---| -| 端点 404 | 忘了在 `modules/.rs` 里写 `router()` / 忘了在 `modules/mod.rs` 里 merge | 补 `router()` + 补 merge 行 | -| 端点 500 | 表不存在 / spec 没进 `ALL_SPECS` | 补 `schema.sql` + 补 `ALL_SPECS` | -| 启动即退(白名单自检失败) | 新表没进 `db/schema.sql`(或 spec 拼错表名) | 补 DDL / 改 spec 表名(`main.rs` **不用改**) | -| 页面 404 | `App.tsx` 的 Route path ≠ 菜单 `url_address` | 三处对齐 | -| 侧栏没有这个菜单 | `modules/.rs` 没声明 `*_MENU` / 没进 `ALL_MENUS` / 没重启回灌 | 补声明 + 补 `ALL_MENUS` + **重启进程**(不必删库) | -| `check-boundary.sh` 报业务标识符泄漏 | 业务知识写进了平台层(表名 / 菜单 key / 路由前缀) | 挪回业务层;平台层只留**类型**(`EntitySpec` / `MenuSpec`) | -| 非管理员也能看 | `module_key` 是 `None` | 改成 `Some("app/Entity")` | -| 非管理员看不到也访问不了(预期) | 没授权 | 写 `base_authorize` 或调授权接口 | -| 金额变成 `9.9` | numeric 列没标 `numeric: true` | spec 标上 + `numeric_columns` 同步 | -| 改了 schema 不生效 | schema 只在首次建表执行 | 清空 `data/` 重建 | -| `check-module.sh` 退出码 2 | 契约 `[MODULE]` 里没加这个 appCode/Entity | 在 `docs/contract.md` 附录 A 加一行(**别改脚本**) | -| `check-contract.sh` 报「代码里的 xxx 没被契约登记」 | 契约附录 A 的 `[ENDPOINT]` 漏了这个模块的 3 条端点 | 补 `[ENDPOINT]` 三行(`face=A` / `guard` = `module_key` / `owner` = 模块代号) | -| `check-contract.sh` 报「守卫漂移」 | 契约写的 `guard` 与代码里的守卫不一致(多半是 `module_key` 改了) | 两边对齐(要么改 `spec.module_key`,要么改契约那一行) | -| `check-contract.sh` 报 ⚠️「推不出守卫」 | 代码里守卫的**写法**变了,扫描器静态推不出来 | 人工核对;确实是新写法 ⇒ 同步改扫描器(`check-contract-scan.py` 的 `guard_of_platform`) | -| 闸门报「尺子被改弱了」 | 加/删了断言但没同步契约 `[RULER]` | 同步契约里那一列(这是故意的提醒) | -| 建了重复账号 | 官方 `f_account` **无 UNIQUE** | 唯一性**应用层**保证(只比 `delete_mark=0` 的行) | +| 加一列 | `packs//src/lib.rs` 的 `*_COLUMNS` + `schema/001_init.sql` | 新库直接生效;**老库要自己 `ALTER TABLE`**(DDL 是 `IF NOT EXISTS`,不会改已有表) | +| 改菜单名 / 排序 | `packs//src/lib.rs` 的 `*_MENU` | 重启;种子幂等(按 `f_id`) | +| 加面 B 路由 | `*_ROUTES`(**每条实体恒 3 条**,别加第 4 条) | 重启 | +| 加面 A 路由 | `modules/.rs` 的 `ROUTES` + handler + `router()` | 重启 | +| 改 `pack.toml` | 改了就跑 `python3 scripts/pack-sync.py` | 忘了 `--check` 会红 | + +## 五、验证 + +```bash +python3 scripts/pack-sync.py --check # 生成物不漂移 +python3 scripts/check-scaffold.py # 本仓只准有业务(6 条) +cargo test --workspace # 包自检 + 应用装配 +bash scripts/perm-smoke.sh # 面 A 32 条(默认自起隔离后端) +bash scripts/perm-smoke-jnpf.sh # 面 B 18 条 +bash scripts/verify.sh # 上面全部,一条命令 +``` + +### 5.1 追加断言(别新写脚本) + +新模块要证明「真的能用」,加到 `scripts/perm-smoke.sh` 里(照 demo / shop / books 的段落抄): + +```bash +# 新建 → 断言主键 36 位 → 断言 numeric 往返是 JSON 字符串 → 无 token 600 → 未授权 403 +``` + +🔴 **加了断言必须同步契约**:`docs/contract.md` 附录 A 的 `[RULER]` 里 +`perm-smoke.sh` 的条数要改成实际值,否则尺子自证失败(**这是故意的**:防止有人把尺子改弱)。 +同理 `[MENU_TREE]`(菜单树字符串)、`[MENU]` / `[MODULE]` / `[ENDPOINT]` 三张表也要同步。 + +### 5.2 前端(可选) + +前端是 `src/frontend/`(React + Vite): + +1. `src/frontend/src/api/.ts` —— 3 个函数(`list` / `save` / `del`),照 `api/product.ts`; +2. `src/frontend/src/views/.tsx` —— 列表页,照 `views/Product.tsx`; +3. `src/frontend/src/App.tsx` —— 注册路由(**path 必须等于菜单 `url_address`**)。 + +改完 `cd src/frontend && npm run build` ⇒ 产物落 `src/frontend/dist/`,后端直接托管。 + +## 六、常见坑 + +| 现象 | 原因 | 修法 | +|---|---|---| +| 面 A 全部 404 | 包没被装载 | 看 `packs_gen.rs` 的 `>>>GEN:PACKS` 段;跑 `pack-sync.py` | +| 面 B 全部 404 | `PackRoute` 路径不是官方形状 | `/api/{app}/{Entity}` + `/api/{app}/{Entity}/{id}` 才对 | +| 装包报 `KernelMismatch` | `kernel` 区间不含当前契约版本 | 改区间(当前 `>=0.4,<0.5`) | +| 装包报 `AppCodeMismatch` | `pack.toml` 的 `app_code` ≠ 目录名 | 改成一致 | +| 启动报「DDL 试图建 base_*」 | 包 DDL 里写了平台表 | 删掉;平台表归 `sspf` | +| 启动报「缺 f_tenant_id / 复合主键」 | 包 DDL 少了租户列 | 按 §3.2 补 | +| 菜单树里没有新模块 | `BusinessPack::menus()` 没返回它 | 补 `&[_MENU]` | +| 非管理员访问新模块 403 | 没给该用户授权 | 正常行为(管理员短路) | +| 非管理员访问新模块 200(本该 403) | `module_key` ≠ `url_address` ⇒ 查不到菜单 ⇒ **放行** | 两处改成一致 | +| `cargo check` 报找不到 `sspf` | 没网 / Gitea 不通 | 见 `~/.cargo/git` 缓存;确认 tag 存在 | + +## 七、写之前的自查 + +1. **表名 / 列名对不对齐基线**?(迁 JNPF 时靠列名导数据) +2. **`module_key` == `url_address` == 前端 Route path**?(三处一字不差) +3. **有金额列吗**?有 ⇒ 必须 `NUMERIC` 且进 `numeric_columns`(JSON 字符串 `"9.90"`)。 +4. **DDL 幂等吗**?`IF NOT EXISTS` + `f_tenant_id` + 复合主键。 +5. **改了 `pack.toml` 跑 `pack-sync.py` 了吗**? diff --git a/README.md b/README.md index 7a7e1bc..c69baaa 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,13 @@ # ssw-jnpf-lite-rust · Rust 全栈 MVP -**自包含技能**:模板、契约实现、权限模版、冒烟脚本全部在技能目录内,**不依赖任何其它技能或外部服务**, -除 Node 外无需安装任何东西(数据库是**进程内原生 PostgreSQL**)。 +**平台来自已发布的 `sspf` 包**(`Cargo.toml` 里 `git` + `tag = "v0.4.0"`),本仓只有 +**业务样板(`packs/`)+ 面 A 适配器 + 薄装配 + 前端产物 + 两把运行时尺子**。 +数据库仍是**进程内原生 PostgreSQL**(由平台包提供),除 Node 外无需装任何东西。 + +> 🔴 **2026-11-04 架构变更**:以前本仓自带一份平台实现(`src/backend/src/platform/` + `routes.rs`,约 4000 行), +> 那是「示例仓里躺着一份会分叉的平台」。现在平台只在 `sspf` 一处演进,本仓锁 tag; +> 升级平台 = 改 `Cargo.toml` 里那一行,业务代码不动。 +> 判据:`python3 scripts/check-scaffold.py`(本仓出现 `platform/` / `routes.rs` / `crates/` 立刻红)。 来自 `ssw-jnpf-lite-react`(NestJS + React)的 **Rust 全栈 counterpart**——两者是**并列可选**的独立技能, 不是依赖关系:要 MVP 期就用 Node 栈选 `ssw-jnpf-lite-react`,要 MVP 期用 Rust 栈选本技能。 @@ -46,56 +52,53 @@ | 适合谁 | 想要 Rust 性能/单二进制,且要保迁移性 | 团队/AI 更熟 Node | 已经是 Java 团队,不打算换栈 | **一句话**:**MVP 期用哪种栈都行,代价是「稳定期迁 JNPF」这件事**。 -本技能把「快」放在 MVP 期(Rust),把「换栈」推迟并**锁死到有界范围**(5 件事 + 六道闸门)。 +本技能把「快」放在 MVP 期(Rust),把「换栈」推迟并**锁死到有界范围**(5 件契约 + 两把运行时尺子)。 若你**本来就要用 Java**,直接用 `ssw-jnpf-lite`(零迁移摩擦)比绕一圈更划算。 ## 目录 ``` ssw-jnpf-lite-rust/ ← 仓根 = 技能根(三处软链指向这里) -├── SKILL.md # 入口:是什么 / 何时用 / 契约红线 / 六道闸门 +├── SKILL.md # 入口:是什么 / 何时用 / 契约红线 / 判据 ├── README.md # 本文件:选型 / 运行 / 验收门 / 已知限制 -├── HOWTO_MODULE.md # 加一个业务模块的操作手册(8 个文件 / 10 个接触点) +├── HOWTO_MODULE.md # 加一个业务模块的操作手册 ├── PERMISSION.md # 权限模版:表结构 / 四源合并 / 码表 ├── MIGRATION.md # 迁移指南(Rust ⇄ NestJS ⇄ 官方 JNPF Java) ├── JNPF_SOURCE_AUDIT.md # 官方源码逐行核对报告(标 文件:行号) ├── JNPF_COMPAT_SURFACE.md # 面 B 规格书:官方形状端点 + 落地顺序 S1–S6 ├── CLAUDE.md / HANDOFF.md # 项目级 agent 指引 / 交接文档 ├── run.sh # install / build / dev / backend / frontend / stop / logs -├── Cargo.toml # 🔴 cargo workspace 根(**复制脚手架时必须一起带走**) +├── Cargo.toml # 🔴 workspace 根:**唯一的平台依赖**(sspf 的 git tag)就在这儿 ├── .env.example # PORT / BIND_ADDR / PGLITE_DIR ├── scripts/ -│ ├── perm-smoke.sh # 契约尺子·面 A(32 条) -│ ├── perm-smoke-jnpf.sh # 契约尺子·面 B(18 条)★ 本技能独有 +│ ├── verify.sh # 一键验收(静态 + 全量测试 + 两把运行时尺子) +│ ├── check-scaffold.py # 静态判据 SC1–SC6「本仓只准有业务」+ --self-test 6/6 +│ ├── pack-sync.py # 从 packs/* + modules/* 生成四处派生位置;--check 防漂移 +│ ├── new-pack.sh # 造包:packs// + modules/.rs + 跑生成 +│ ├── perm-smoke.sh # 运行时尺子·面 A(32 条) +│ ├── perm-smoke-jnpf.sh # 运行时尺子·面 B(18 条)★ 本技能独有 │ ├── smoke_backend.sh # 两把尺子的「隔离后端」自启动助手(默认自起 ⇒ CI 可跑) -│ ├── check-module.sh # 静态闸门 1:业务模块 10 接触点自检(93 条) -│ ├── check-boundary.sh # 静态闸门 2:分层红线 CP1–CP6 自检(11 条) -│ ├── check-boundary-scan.py # 分层闸门的扫描器(禁用词表由业务层反推 + 自测模式) -│ ├── check-contract.sh # 静态闸门 3:契约端点表 + 官方端点台账 ↔ 代码真实路由 对账(10 条)★ 本技能独有 -│ ├── check-contract-scan.py # 上面那个的扫描器(Rust 源码静态解析 + 9 例反自证) -│ ├── check-citations.sh # 静态闸门 4:文档引文 `路径:行号` 逐条核对(4 条)★ 本技能独有 -│ ├── check-citations-scan.py # 上面那个的扫描器(引文解析 + 3 例反自证) │ ├── contract_expect.py # 读 docs/contract.md 附录 A(机器可读期望值)—— 尺子的唯一期望源 │ ├── reap-ipc-leaks.sh # macOS SysV 信号量泄漏回收(PGlite 专用) │ └── ipc-reap.c # 上面那个的 C 实现 +├── packs/ # 【业务真源】整目录可搬;每个包只依赖 sspf 门面 +│ ├── demo★/ # {Cargo.toml, pack.toml, schema/001_init.sql, src/lib.rs} +│ ├── shop★/ books★/ asset★/ ├── src/ -│ ├── backend/ # Rust 后端 -│ │ ├── src/{main,lib,routes,bootstrap}.rs # bootstrap = 装配根(唯一同时认识两层的地方) -│ │ ├── src/platform/ # 【平台层】{config,db,cipher,envelope,ids,session,state,auth,permission,seed,sys,jnpf,entity,crud,menu,guard}.rs -│ │ ├── src/modules/ # 【业务层】{mod,demo★,shop★,books★}.rs(各带 spec + handler + router + 菜单声明) -│ │ ├── db/schema.sql # 10 张表(base_* 7 + 业务 3) -│ │ └── tests/ # 7 个集成测试文件 -│ └── frontend/ # React + Vite(1374 行) -│ ├── utils/cipher · api/{request,auth,sys,product,book} -│ └── views/{Login,Dashboard,DemoItem★,Product★,Book★,UserManage,RoleManage,OrganizeManage,MenuManage} +│ ├── backend/ # 示例应用(薄壳) +│ │ ├── src/main.rs # 解析 --enc/--help + 交给 sspf::Platform 装配 +│ │ ├── src/lib.rs # pub mod modules; pub mod packs_gen; +│ │ ├── src/packs_gen.rs # 业务包清单(装载 packs/*)—— 生成物,别手改 +│ │ └── src/modules/ # 【面 A 适配器】{mod,demo★,shop★,books★,asset★}.rs +│ └── frontend/ # React + Vite(含已打好的 dist/,后端直接托管) ├── references/ # BaseCrudController.java(**非** JNPF 官方类)+ README ├── template-boot-jnpf/ # JNPF 标准栈最小可运行骨架(Java) -└── docs/ # 项目级文档(契约真源 / 运维 / 裁决 / DDL) - ├── contract.md # 【契约唯一真源】端点 / 返回形状 / 数据模型 +└── docs/ # 契约真源 / 运维 / 裁决 / DDL + ├── contract.md # 【契约唯一真源】端点 / 返回形状 / 数据模型 / 附录 A 机器段 ├── runbook.md # 怎么起 / 怎么冒烟 / 常见故障 - ├── decisions.md # 实施期逐条裁决(98 条「什么—为什么—代价」) - ├── known-limitations.md # 分支级已知限制(被接受/挂起的东西) - └── ddl/ # 官方 DDL 摘录 + ├── decisions.md # 实施期逐条裁决 + ├── known-limitations.md # 分支级已知限制 + └── ddl/ # 官方 DDL 摘录(说明实物,不参与运行) ``` ★ = 业务模块模板(`HOWTO_MODULE.md` 参照实现)。 @@ -130,41 +133,39 @@ bash run.sh logs # 看日志尾部 ```bash SKILL=~/.agents/skills/ssw-jnpf-lite-rust # 软链 ⇒ 实际指向本仓 PROJ=~/Desktop/my-app -mkdir -p "$PROJ/src" # 脚手架固定进 src/:没有则创建,已有则并入 -rsync -a --exclude node_modules --exclude dist --exclude target --exclude data --exclude .DS_Store \ - "$SKILL"/src "$SKILL"/scripts "$SKILL"/run.sh "$SKILL"/Cargo.toml "$SKILL"/.env.example "$SKILL"/.gitignore "$PROJ"/ +mkdir -p "$PROJ" +rsync -a --exclude node_modules --exclude target --exclude data --exclude .DS_Store \ + "$SKILL"/src "$SKILL"/packs "$SKILL"/scripts "$SKILL"/run.sh \ + "$SKILL"/Cargo.toml "$SKILL"/.env.example "$SKILL"/.gitignore "$PROJ"/ cd "$PROJ" && cp .env.example .env && ./run.sh install && ./run.sh dev ``` -> ⚠️ **只复制脚手架本体**——`*.md` / `references/` / `template-boot-jnpf/` 是技能资产,留在技能目录只读引用。 -> 全量 `cp -R` 会让项目目录混满技能噪音,日后技能升级也灌不进项目。 -> 🔴 **`Cargo.toml`(workspace 根)别漏**:缺了它 `src/backend` 的 `workspace = true` 继承无处可依 ⇒ cargo 直接报 -> `could not find Cargo.toml in ... or any parent directory`,**脚手架编译不起来**。 +> ⚠️ **只复制脚手架本体**——`*.md` / `references/` / `template-boot-jnpf/` / `docs/` 是技能资产, +> 留在技能目录只读引用。全量 `cp -R` 会让项目目录混满技能噪音,日后技能升级也灌不进项目。 +> 🔴 **`packs/` 必须一起复制**:业务真源在包里 ⇒ 少了它应用能起但**面 A 全 404**。 +> 🔴 **`Cargo.toml`(workspace 根)别漏**:`sspf` 的 git tag 就在里面, +> 缺了它 `src/backend` 的 `workspace = true` 继承无处可依 ⇒ 编译不起来。 ## 验收门 +一条命令:`bash scripts/verify.sh`(全量 7 步)/ `--fast`(静态 + 测试 4 步)。 + | 门 | 命令 | 通过标准 | |---|---|---| -| ① 编译 | `cargo build --release` | 0 error **0 warning** | -| ② 单测 | `cargo test` | 全绿(当前 **220 passed / 0 failed**) | -| ③ 冒烟(面 A) | `bash scripts/perm-smoke.sh` | **PASS=32 FAIL=0**(🔴 **后端不用先起**:`:30010` 不通 ⇒ 尺子自起隔离实例,跑完即删) | -| ③' 冒烟(面 B) | `bash scripts/perm-smoke-jnpf.sh` | **PASS=18 FAIL=0 SKIP=0**(**已达标**;同样默认自起隔离实例) | -| ④ 前端手验 | `bash run.sh dev` | `http://127.0.0.1:5173` → `admin/123456` 登录 → 菜单树正确 → 5 个管理页可增删改 → DemoItem/Product/Book 三页可用 → 退出再登录 | +| ① 生成物 | `python3 scripts/pack-sync.py --check` | 无漂移(4 个包 / 4 个模块) | +| ② 只准有业务 | `python3 scripts/check-scaffold.py` | **SC1–SC6 全绿**;`--self-test` **6/6**(每条判据都能被证伪) | +| ③ 编译 + 单测 | `cargo build --release` + `cargo test --workspace` | 0 error;测试全绿 | +| ④ 运行时尺子·面 A | `bash scripts/perm-smoke.sh` | **PASS=32 FAIL=0**(🔴 后端不用先起:`:30010` 不通 ⇒ 自起隔离实例,跑完即删) | +| ⑤ 运行时尺子·面 B | `bash scripts/perm-smoke-jnpf.sh` | **PASS=18 FAIL=0 SKIP=0**(结尾打印「面 B 覆盖 18/18」) | +| ⑥ 前端手验 | `bash run.sh dev` | `http://127.0.0.1:5173` → `admin/123456` → 菜单树正确 → 5 个管理页可增删改 → DemoItem/Product/Book 三页可用 | -外加四道**静态闸门**(纯静态,不起后端,加业务模块后立刻跑): -`bash scripts/check-module.sh`(10 接触点,93 条)+ `bash scripts/check-boundary.sh`(分层红线 CP1–CP6,11 条) -+ `bash scripts/check-contract.sh`(契约端点表 + 官方端点台账 ↔ 代码真实路由,10 条) -+ `bash scripts/check-citations.sh`(文档引文 `路径:行号`,4 条)。 +🔴 **期望值只有一处**:`docs/contract.md` **附录 A**(`[MENU]` / `[MENU_TREE]` / `[MODULE]` / +`[ENDPOINT]` / `[FACE]` / `[RULER]`),由 `scripts/contract_expect.py` 解析 ⇒ 改契约只改一处; +每把运行时尺子还**自证**自己的条数(被人改弱了 ⇒ 失败)。 -🔴 **六把尺子的期望值只有一处**:`docs/contract.md` **附录 A**(机器可读), -由 `scripts/contract_expect.py` 解析 ⇒ 改契约只改一处;代码漂移尺子立刻报; -每把尺子还**自证**自己的条数(被人改弱了 ⇒ 失败)。 - -📊 **官方端点覆盖是一本「账」**:附录 A 的 `[OFFICIAL]` 区段(53 行)把官方 JNPF 契约面的 -端点全表变成**机器可读**的覆盖账本(`implemented` / `partial` / `absent` / `oos` 四态)⇒ -`check-contract.sh` 的 **CC10** 拿它与**代码真实路由双向对账**,并打印 -**「官方端点覆盖 N/M」**(当前 **8/47**)—— **算出来的,不是人数的**; -台账的 `src` 列是官方出处 `文件:行号` ⇒ 由引文闸门**逐条核对**。 +🔴 **旧的「六道闸门」已退役**(`check-module` / `check-boundary` / `check-contract` / `check-citations`): +它们测的是**本仓那份平台实现**,平台搬走后没有测量对象 —— 留着就是假绿。 +新的判据只有「本仓只准有业务」(`check-scaffold.py`)与「业务真的能跑」(`cargo test` + 两把尺子)。 ## 数据库:进程内原生 PostgreSQL @@ -181,7 +182,7 @@ cd "$PROJ" && cp .env.example .env && ./run.sh install && ./run.sh dev | 限制 | 说明 | |---|---| -| **面 B 仍有 10 条偏差** | 面 B 已落地(`src/backend/src/platform/jnpf.rs`,尺子 **18/18 全绿**),但 `AuthorizeDataReturnVO.list` 返空数组 · `sysConfigInfo` 返 `{}` · 无按钮/列/表单/数据级权限 · 业务菜单 `f_en_code` 是自拟占位 · `permissionList` 粒度 = 每菜单一条 · `Organize/AsyncList` 未分页 —— 逐条见 `JNPF_COMPAT_SURFACE.md` §8(B1–B10) | +| **面 B 仍有 10 条偏差** | 面 B 已落地(实现在 `sspf` 包内,本仓尺子 **18/18 全绿**),但 `AuthorizeDataReturnVO.list` 返空数组 · `sysConfigInfo` 返 `{}` · 无按钮/列/表单/数据级权限 · 业务菜单 `f_en_code` 是自拟占位 · `permissionList` 粒度 = 每菜单一条 · `Organize/AsyncList` 未分页 —— 逐条见 `JNPF_COMPAT_SURFACE.md` §8(B1–B10) | | 不分页(**面 A**) | 面 A 契约里的 `List` 就是全量(前端不分页);要分页是 JNPF 稳定期的 `SuperServiceImpl.page`(**面 B 已是分页信封**) | | 不做按钮/列/表单/数据范围级授权 | 官方 DDL 里有 `base_module_button` / `_column` / `_form` / `_data`,v1 只做 `item_type='module'` | | 不做多租户 | 单租户固定 `f_tenant_id='0'` | diff --git a/SKILL.md b/SKILL.md index 8448270..dcd08c0 100644 --- a/SKILL.md +++ b/SKILL.md @@ -1,13 +1,22 @@ --- name: ssw-jnpf-lite-rust -description: Rust 全栈 MVP 脚手架,契约与数据模型从第一天起对齐 JNPF 标准版(cipher / ActionResult / f_ 列 / varchar(50) UUID / base_* 权限表 / 进程内原生 PostgreSQL),前后端同一进程同时提供「面 A(ssw 契约 27 条)」与「面 B(官方 JNPF 形状 5 条 + 2 条共用按 Vue-Version 头分流)」两套契约。适用于「AI 开发 MVP 阶段要 Rust 全栈快速迭代、稳定后迁 JNPF 标准栈」的场景,含用户/角色/机构/菜单/授权五套管理页与四源合并菜单守卫。加业务模块见同目录 HOWTO_MODULE.md。 +description: Rust 全栈 MVP 脚手架(**平台来自已发布的 sspf 包,锁 git tag**;本仓只有业务样板 + 薄装配 + 前端产物 + 尺子),契约与数据模型从第一天起对齐 JNPF 标准版(cipher / ActionResult / f_ 列 / varchar(50) UUID / base_* 权限表 / 进程内原生 PostgreSQL),前后端同一进程同时提供「面 A(ssw 契约 30 条)」与「面 B(官方 JNPF 形状 5 条 + 2 条共用按 Vue-Version 头分流)」两套契约。适用于「AI 开发 MVP 阶段要 Rust 全栈快速迭代、稳定后迁 JNPF 标准栈」的场景,含用户/角色/机构/菜单/授权五套管理页与四源合并菜单守卫。加业务模块见同目录 HOWTO_MODULE.md。 type: skill --- # ssw-jnpf-lite-rust -**自包含技能**:Rust 后端(axum 0.8 + 进程内原生 PostgreSQL)+ React 前端 + 两把冒烟尺子, -全部在技能目录内,**不依赖任何其它技能或外部服务**(无 Docker、无 Redis、无外部 PG、**除 Node 外无需装任何东西**)。 +**技能 = 业务样板 + 薄装配 + 前端产物 + 两把尺子**;**平台不在本仓**。 +平台(登录 / 权限 / 面 A·B / 低代码 / MCP / 177 张 `base_*` 表 / 进程内原生 PostgreSQL) +来自**已发布的 `sspf` 包**(`Cargo.toml` 里的 `git` + `tag = "v0.4.0"`)。 + +> 🔴 **这条是 2026-11-04 的架构变更**:以前本技能自带一份平台实现(`src/backend/src/platform/`), +> 结果是「示例仓里躺着一份会分叉的平台」。现在平台只在 `sspf` 一处演进,本仓锁 **tag**; +> 升级平台 = 改 `Cargo.toml` 里那一行 tag,业务代码不动。 +> 判据:`python3 scripts/check-scaffold.py`(本仓出现 `platform/` / `routes.rs` / `crates/` 立刻红)。 +> +> **依赖前提**:能访问 `http://127.0.0.1:13300/ssw/ssw-platform.git`(本机 Gitea)。 +> 首次 `cargo build` 会拉一次 git 依赖,之后走 `~/.cargo/git` 缓存。 来自 `ssw-jnpf-lite-react`(NestJS + React)的 **Rust 全栈 counterpart**——两者是**并列可选**的独立技能, 不是依赖关系:要 MVP 期就用 Node 栈选 `ssw-jnpf-lite-react`,要 MVP 期用 Rust 栈选本技能。 @@ -43,13 +52,18 @@ type: skill ```bash SKILL=~/.agents/skills/ssw-jnpf-lite-rust # 本技能目录 PROJ=~/Desktop/my-app # 目标项目目录(任意路径) -mkdir -p "$PROJ/src" # 脚手架固定进 src/:没有则创建,已有则并入 -rsync -a --exclude node_modules --exclude dist --exclude target --exclude data --exclude .DS_Store \ - "$SKILL"/src "$SKILL"/scripts "$SKILL"/run.sh "$SKILL"/Cargo.toml "$SKILL"/.env.example "$SKILL"/.gitignore "$PROJ"/ +mkdir -p "$PROJ" +rsync -a --exclude node_modules --exclude target --exclude data --exclude .DS_Store \ + "$SKILL"/src "$SKILL"/packs "$SKILL"/scripts "$SKILL"/run.sh \ + "$SKILL"/Cargo.toml "$SKILL"/.env.example "$SKILL"/.gitignore "$PROJ"/ cd "$PROJ" && cp .env.example .env && ./run.sh install && ./run.sh dev # 后端 :30010 + 前端 :5173 → 打开 http://127.0.0.1:5173 → admin / 123456 ``` +> 🔴 **`packs/` 必须一起复制**:业务真源在包里,`packs_gen.rs` 按包清单装载; +> 只复制 `src/` 会得到「能起、但没有业务端点」的空壳(面 A 全 404)。 +> 🔴 复制过去后把 `Cargo.toml` 里的 `sspf` tag 换成你项目要锁的版本 —— 那是**唯一**的平台版本入口。 + > **除 Node 外无外部依赖**——数据库是 **pglite-rs 0.2**(把 postgres-pglite 编译成**原生静态库**链进二进制, > 进程内单 backend,**真实 PostgreSQL 语义**;不是浏览器 WASM 版 PGlite)。数据落盘 `src/backend/data/lite.pg`。 > 🔴 **一个数据目录只能被一个进程打开** ⇒ 别把两个项目的 `PGLITE_DIR` 指到同一处。 @@ -72,22 +86,26 @@ cd "$PROJ" && cp .env.example .env && ./run.sh install && ./run.sh dev **全部指向同一个仓** ⇒ **改一次仓 = 改一次技能**,不存在「技能副本漂移」。 ``` -src/backend/ Rust(axum 0.8 :30010, pglite-rs 0.2 进程内 PG) - src/{main,lib,routes}.rs - src/platform/ 【平台层】加业务模块**一个字都不改** - {config,db,cipher,envelope,ids,session,state,auth,permission,seed,sys,jnpf,entity,crud}.rs - (5 组 base_* 显式 handler · 四源权限 · 面 B · spec 驱动 CRUD 引擎) - src/modules/ 【业务层】加业务模块**只改这里** - {mod,demo★,shop★,books★}.rs ← 每个模块自带 spec + handler + 自己的 router() - db/schema.sql 10 张表(base_* 7 + 业务 3) - tests/ 6 个集成测试文件 -src/frontend/ React+Vite(:5173, proxy /api→30010) - utils/cipher · api/{request,auth,sys,product,book} · views/{Login,Dashboard,DemoItem★,Product★,Book★,UserManage,RoleManage,OrganizeManage,MenuManage} -scripts/ perm-smoke.sh 面 A 尺子(32 条)—— 测 ssw 契约 +Cargo.toml workspace 根:【唯一的平台依赖就在这儿】 + sspf = { git = "http://127.0.0.1:13300/ssw/ssw-platform.git", tag = "v0.4.0" } +src/backend/ 示例应用(薄壳,~500 行) + src/main.rs 解析 --enc/--help + 把「配置 + 包 + 面 A 路由 + 前端」交给 + sspf::Platform::new().config().packs().router().static_dir().serve() + src/lib.rs 只有两行:pub mod modules; pub mod packs_gen; + src/packs_gen.rs 业务包清单(装载 packs/*)—— 生成物,别手改 + src/modules/ 面 A 适配器(/api/ssw/{app}/{Entity}/…,前端在用) + {mod,demo★,shop★,books★,asset★}.rs ← 每个只做 spec 转发 + 3 个 handler + data/ pglite 数据目录(gitignored) +src/frontend/ React+Vite(:5173, proxy /api→30010) + 已打好的 dist/(后端直接托管) +packs/ 业务真源(每个包整目录可搬) + {demo★,shop★,books★,asset★}/ {Cargo.toml, pack.toml, schema/001_init.sql, src/lib.rs} + ↑ 表 DDL + 列 + 菜单 + 面 B 路由都在这儿;只依赖 sspf 门面 +scripts/ verify.sh 一键验收(静态 + 全量测试 + 两把运行时尺子) + check-scaffold.py 「本仓只准有业务」6 条判据 + --self-test 6/6 + pack-sync.py 从 packs/* + modules/* 生成四处派生位置;--check 防漂移 + new-pack.sh 造包(packs// + modules/.rs + 跑生成) + perm-smoke.sh 面 A 尺子(32 条)—— 测 ssw 契约 perm-smoke-jnpf.sh 面 B 尺子(18 条)—— 测官方 JNPF 形状 ★ 本技能独有 - check-module.sh 业务模块 10 接触点静态自检(纯静态,不起后端) - check-boundary.sh 分层红线 CP1–CP6 静态自检(纯静态,不起后端) - check-contract.sh 契约端点表 ↔ 代码真实路由 静态对账(纯静态,不起后端)★ 本技能独有 smoke_backend.sh 契约尺子的「隔离后端」自启动助手(被两把尺子 source) contract_expect.py 读 docs/contract.md 附录 A(机器可读期望值)—— 尺子的唯一期望源 references/ BaseCrudController.java(**非** JNPF 官方类)+ README @@ -127,77 +145,57 @@ template-boot-jnpf/ JNPF 标准栈最小可运行骨架(Java)—— 迁官 10. **菜单 `url_address` == 前端 `Route path`(去前导斜杠)== spec 的 `module_key`**,三处一字不差。 不一致的后果是**静默放行**(未映射到菜单就放行)。 11. 🔴 **同一文件的多个 Edit 必须串行**(并行 Edit = last-writer-wins 静默覆盖);改完**必须 grep 复核**。 -12. 🔴 **平台层 / 业务层分离**:`src/platform/` = 契约实现(**不许出现业务表名 / app_code / 菜单 key**); - `src/modules/` = 业务 spec + handler + 路由 + **自己的菜单声明**(`*_MENU: MenuSpec`)。 - **加业务模块只碰业务层**(平台层一个字都不改)。 - 🔴 平台层与业务层**唯一**的接头是 `src/bootstrap.rs`(装配根)—— - 它 `seed::ensure_base(db, modules::all_menus())`,是**唯一**允许同时认识两层的文件。 +12. 🔴 **平台 / 业务分离(靠仓库边界,不靠目录纪律)**: + 平台 = 已发布的 `sspf` 包(**不在本仓**);业务 = `packs//`(真源)+ `src/backend/src/modules/.rs`(面 A 适配器)。 + **加业务模块只碰业务**,平台一个字都不用改 —— 因为它根本不在本仓。 + 🔴 两者唯一的接头是 `sspf::Platform::new().packs(reg).router(modules::router())`(`main.rs`)。 + 🔴 **spec 只有一份**:在 `packs//src/lib.rs`;`modules/.rs` 只 `pub use` 转发 + (两份拷贝迟早分叉)。 + 🔴 **业务菜单不要传给 `.menus()`**:`.packs(reg)` 已把 `PackRegistry.menus` 带进两段式种子, + 给两次会在种子里撞主键。 -## 六道闸门(**都要跑**) +## 判据(**都要跑**) -🔴 **六道闸门分两类**:前四道是**静态闸门**(不起后端,纯读源码/契约/文档), -后两道是**契约尺子**(起后端打真实 HTTP)。**契约尺子 = 「两把尺子」**(面 A / 面 B)—— -这个说法在历史文档里沿用下来了,但**实际有六道**,别按「两把」理解。 +> 🔴 **2026-11-04 起从「六道闸门」减到「两类判据」**:原来的 `check-module` / `check-boundary` / +> `check-contract` / `check-citations` 四把静态尺子测的是**本仓那份平台实现**(分层、契约对账、引文)。 +> 平台搬走之后它们没有测量对象了 —— 保留等于**假绿**。现在只剩两类,各司其职: -| | `scripts/check-module.sh` | `scripts/check-boundary.sh` | `scripts/check-contract.sh` | `scripts/check-citations.sh` | `scripts/perm-smoke.sh` | `scripts/perm-smoke-jnpf.sh` | -|---|---|---|---|---|---|---| -| 类别 | 静态闸门 | 静态闸门 | 静态闸门 | 静态闸门 | **契约尺子·面 A** | **契约尺子·面 B** | -| 测什么 | 业务模块 **10 接触点**是否齐 | **分层红线 CP1–CP6**(平台层不许出现业务知识) | **契约端点表 + 官方端点台账 ↔ 代码真实路由**(CC2–CC10:总数/方法/归属/守卫/覆盖账,双向) | **文档引文**(`路径:行号` 是否还指得到真东西)+ DDL 行号表 | **面 A**(ssw 契约) | **面 B**(官方 JNPF 形状) | -| 起后端 | 否 | 否 | 否 | 否 | 是(**默认自起隔离实例**) | 是(**默认自起隔离实例**) | -| 判别 | 无 | 无 | 无 | 无 | 无特殊头 | 请求头带 `Vue-Version: 3` | -| 断言数 | **93**(3 模块合计) | **11** | **10** | **4** | **32** | **18** | -| 退出码 | 0 全绿 / 1 有失败 / 2 用法错 | 同左 | 同左 | 同左 | 0 全绿 / 1 有失败 / 2 前置错误 | 0 全绿 / 1 有失败或未全覆盖 / 2 前置错误 | +| | `scripts/check-scaffold.py` | `cargo test --workspace` | `scripts/perm-smoke.sh` | `scripts/perm-smoke-jnpf.sh` | +|---|---|---|---|---| +| 类别 | 静态判据 | 单元 / 集成测试 | **运行时尺子·面 A** | **运行时尺子·面 B** | +| 测什么 | **本仓只准有业务**(SC1–SC6:没有 platform/、没有 `base_*` 建表、应用只依赖门面、包只依赖门面、`sspf` 锁 git tag、生成物不漂移) | 包自检(列/DDL/路由形状)+ 应用装配 + spec 唯一性 + sync 一致性 | 面 A 契约 32 条 | 官方 JNPF 形状 18 条 | +| 起后端 | 否 | 否 | 是(**默认自起隔离实例**) | 是(**默认自起隔离实例**) | +| 断言数 | **6**(+ 反自证 **6/6**) | 按 workspace | **32** | **18** | ```bash -bash scripts/check-module.sh # 静态闸门 1:业务模块 10 接触点(纯静态,不起后端) -bash scripts/check-boundary.sh # 静态闸门 2:分层红线 CP1–CP6(纯静态,不起后端) -bash scripts/check-contract.sh # 静态闸门 3:契约端点表 ↔ 代码真实路由(纯静态,不起后端) -bash scripts/check-citations.sh # 静态闸门 4:文档引文 `路径:行号` 逐条核对(纯静态,不起后端) -bash scripts/perm-smoke.sh # 契约尺子·面 A:32 条 —— 「没把原契约改坏」 -bash scripts/perm-smoke-jnpf.sh # 契约尺子·面 B:18 条 —— 打印「面 B 覆盖 N/18」(**当前 N=18,已全绿**) +bash scripts/verify.sh # 一键:pack-sync --check → check-scaffold → 自证 → cargo test → 两把尺子 +bash scripts/verify.sh --fast # 只静态 + cargo test(不起服务) + +python3 scripts/check-scaffold.py # 单独跑 6 条判据 +python3 scripts/check-scaffold.py --self-test # 反自证:每条判据造一个真实违规,必须红 +python3 scripts/pack-sync.py --check # 生成物漂移(加包忘了跑 sync) +bash scripts/perm-smoke.sh # 面 A:32 条 +bash scripts/perm-smoke-jnpf.sh # 面 B:18 条(结尾打印「面 B 覆盖 N/18」) ``` -🔴 **期望值只有一处**:`docs/contract.md` **附录 A**(机器可读区段 `[MENU]` / `[MENU_TREE]` / -`[MODULE]` / `[ENDPOINT]` / `[FACE]` / `[RULER]`,由 `scripts/contract_expect.py` 解析)。 -菜单表、业务模块清单、**端点表(路径/方法/守卫/归属)**、各尺子的断言条数**都不在脚本里** ⇒ -① 改契约只改一处;② 代码漂移尺子立刻报;③ 加模块不用改尺子。 -🔴 **每把尺子都自证**:结尾比对「本尺子实际跑了多少条断言」与「契约登记的条数」, -对不上 ⇒ **失败** ⇒ 尺子不会被人悄悄改弱。 +🔴 **期望值只有一处**:`docs/contract.md` **附录 A**(`[MENU]` / `[MENU_TREE]` / `[MODULE]` / +`[ENDPOINT]` / `[FACE]` / `[RULER]`,由 `scripts/contract_expect.py` 解析)。 +两把运行时尺子的**菜单树与断言条数**都从那里读 ⇒ 改契约只改一处;尺子被改弱(条数对不上)⇒ 自证失败。 -- **面 B 尺子不假装全过**:未落地的能力记 **SKIP**(不算 PASS),结尾打印 **「面 B 覆盖 N/18」** ⇒ 它是一把**诚实量进度**的尺子。 - ✅ **2026-10-26 当前状态:面 B 已落地 ⇒ `PASS=18 FAIL=0 SKIP=0`(覆盖 18/18)**; - `SKIP` 机制**保留**(后续新增端点未落地时仍如实记 SKIP)。 -- **分层闸门自带防自证**:`scripts/check-boundary-scan.py` 的**禁用词表由业务层自己反推** - (表名 / 实体名 / 路由前缀 / 菜单 id / `en_code` / `url_address`)⇒ 加模块自动加严; - 且它有 `--self-test` 自测模式(造一棵假的 modules/platform 树,断言**恰好**抓到 1 处泄漏) - ⇒ 扫描器不会悄悄退化成"永远通过"的空壳。 -- **契约闸门自带防自证**:`scripts/check-contract-scan.py --self-test` 造 **9 种已知漂移** - (契约多一条 / 少一条 / 方法写错 / 守卫写错 / 归属层写错 / 契约面计数写错 / - 台账把已实现的端点说成未实现 / 台账写了代码里没有的端点 / 面 B 路由没记账) - ⇒ 断言**每一种都被抓到**;且先验「真实契约零漂移」⇒ 扫描器不会退化成"永远通过"的空壳。 - 🔴 守卫对账是**静态推导**的(面A 菜单 key / 面B 点权限编码 / 登录 / 无); -- **引文闸门自带防自证**:`scripts/check-citations-scan.py --self-test` 注入 **3 类坏引用** - (行号越界 / 文件不存在 / DDL 行号错位)⇒ 断言**每一种都被抓到**,且先验「干净引文不误报」 - ⇒ 扫描器不会退化成"永远通过"的空壳。 - 🔴 **外部参照根缺失 ⇒ 判「跳过」不判失败**(官方源码 / react 技能 / cargo registry 都不在本机时, - 本闸门只校验本仓内的引文);引文里「无路径的续行行号」(`:NNN`)**只报不判失败** - —— 表格里相邻两行可能指不同文件 ⇒ 机械继承会误报。 - 推不出来的路由会报 **WARN**(推不出 ≠ 一致,要人工核对),不会假装通过。 -- **官方端点覆盖是一本「账」**:官方 JNPF 契约面的端点全表在 `JNPF_SOURCE_AUDIT.md` §4(散文表格), - 本仓的**覆盖账本**在 `docs/contract.md` 附录 A 的 `[OFFICIAL]`(**机器可读**)⇒ - `check-contract.sh` 的 **CC10** 拿它与**代码真实路由双向对账**,并打印 - **「官方端点覆盖 N/M」**(当前 **8/47**;`oos` 6 条单列不进分母)。 - 状态词表:`implemented`(已落地且形状对齐)/ `partial`(已落地但**形状有偏差**, - 偏差见 `JNPF_COMPAT_SURFACE.md` §8 的 B1–B10)/ `absent`(未实现,可后置)/ `oos`(v1 明确不做)。 - 🔴 **面 B / 共用的每条路由都必须在账上**(防止"实现了但没记账"); - 台账的 `src` 列是官方出处 `文件:行号` ⇒ 由引文闸门**逐条核对**(现在 198 条引文全中)。 -- **契约尺子自起隔离后端**:两把尺子**默认不用你先把后端起起来**(助手 `scripts/smoke_backend.sh`): - 没给 `B` ⇒ 先探 `:30010`,**通**就用它、**不通**就**自起隔离实例**(空闲端口 + `mktemp -d` 临时 - `PGLITE_DIR`),跑完即删 ⇒ 两把尺子**互不污染**、不留脏数据、**CI 可跑**。 - 🔴 **显式给了 `B` ⇒ 不自起**,不可达即**退出码 2**(尊重外部后端)。 -- **判读原则**:**返回了数据不能证明权限生效**(管理员短路 / 菜单没映射 / 缓存没清 / 异常降级放行,四条路径全是"放行")。 - 「菜单收窄 + 403 拦截」才是有说服力的信号。 -- **不依赖 node**:cipher 用后端 `--enc` 自证(`./target/release/ssw-jnpf-lite-rust --enc 123456`);JSON 取值 jq 优先、python3 兜底。 +🔴 **每条判据都能被证伪**(这是本仓的硬要求,不是口号): +- `check-scaffold.py --self-test`:给 6 条判据各造一个**真实违规**(抄回 `platform/`、写一条 + `CREATE TABLE base_user`、应用依赖 `sspf-core`、包依赖 `axum`、`sspf` 改成 path、改 `pack.toml` + 让生成物漂移),断言**该条恰好变红**,且注入前基线全绿。 +- 运行时尺子:结尾比对「实际跑了多少条」与契约 `[RULER]` 登记的条数,对不上 ⇒ 失败。 + +🔴 **面 B 尺子不假装全过**:未落地的能力记 **SKIP**(不算 PASS),结尾打印「面 B 覆盖 N/18」。 +当前 **18/18**,机制保留。 + +🔴 **判读原则**:**返回了数据不能证明权限生效**(管理员短路 / 菜单没映射 / 缓存没清 / 异常降级放行, +四条路径全是「放行」)。「菜单收窄 + 403 拦截」才是有说服力的信号。 + +🔴 **不依赖 node**:cipher 用后端 `--enc` 自证(`./target/release/ssw-jnpf-lite-rust --enc 123456`); +JSON 取值 jq 优先、python3 兜底。 ## 文档导航 @@ -219,19 +217,18 @@ bash scripts/perm-smoke-jnpf.sh # 契约尺子·面 B:18 条 —— 打印 ## 校验 -- **cipher**:`src/backend/src/platform/cipher.rs` 顶部注释含检验向量;`./target/release/ssw-jnpf-lite-rust --enc 123456` 一行复现。 -- **加新模块的「10 接触点」静态自检**:`bash scripts/check-module.sh`(无参查契约登记的全部模块) - 或 `bash scripts/check-module.sh books Book`(单模块)。改完模块立刻跑,能在 perm-smoke 之前发现漏改。 -- **分层红线静态自检**:`bash scripts/check-boundary.sh`(CP1–CP6,纯静态)。 - 改完 `platform/` 或 `modules/` 必跑 —— 它专抓「业务知识漏进平台层」和「菜单漏登记」。 -- **契约对账静态自检**:`bash scripts/check-contract.sh`(CC2–CC10,纯静态)。 - 改完 `routes.rs` / `modules/*.rs` / 契约端点表 必跑 —— 它把契约附录 A 的 `[ENDPOINT]` - 与**代码里真实注册的路由**逐条对账(总数 / 方法 / 归属层 / 守卫,双向)⇒ 漏改立刻报。 -- **端到端权限闭环**:`bash scripts/perm-smoke.sh`(32 条)。 - 覆盖:未登录 600 · 加密登录 · 菜单树 · 建用户 · **重复账号返 400 而非 500** · 写授权(一维/二维兼容)· - 非管理员菜单收窄 · 非管理员访问系统管理返 403 · 已授权业务返 200 · 未知路由 404 · - **三个业务模块全链路**(新建 / 36 位 UUID / numeric 金额往返 / 无 token 600 / 未授权 403)。 -- **官方形状达标**:`bash scripts/perm-smoke-jnpf.sh`(18 条)⇒ 「面 B 覆盖 N/18」(**当前 18/18**)。 -- **单测**:`cargo test`(220 条)。 -- **退出码约定一致**:`run.sh` / `check-module.sh` / `check-boundary.sh` / `check-contract.sh` / `perm-smoke*.sh` 都是 `0` 成功 / `1` 运行期失败 / `2` 用法错。 - 各脚本支持 `-h`/`--help`。 +- **一键**:`bash scripts/verify.sh`(全量 7 步)/ `--fast`(静态 + 测试 4 步)。 +- **cipher**:`./target/release/ssw-jnpf-lite-rust --enc 123456` + ⇒ `d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b` + (与官方 `DesUtil` 逐字节一致;平台侧实现在 `sspf` 包内)。 +- **加/改业务包**:`bash scripts/new-pack.sh --name "中文名" --columns "a:VARCHAR(200)"` + ⇒ 建包 + 适配器 + 自动补齐四处生成物;随后 `cargo check` 与 `bash scripts/verify.sh`。 + 忘了跑生成 ⇒ `python3 scripts/pack-sync.py --check` 红。 +- **本仓只准有业务**:`python3 scripts/check-scaffold.py`(6 条)+ `--self-test`(6/6)。 +- **端到端权限闭环**:`bash scripts/perm-smoke.sh`(32 条)。覆盖:未登录 600 · 加密登录 · 菜单树 · + 建用户 · 重复账号返 400 · 写授权(一维/二维兼容)· 非管理员菜单收窄 · 系统管理 403 · + 已授权业务 200 · 未知路由 404 · 四个业务模块全链路(新建 / 36 位 UUID / numeric 往返 / 600 / 403)。 +- **官方形状达标**:`bash scripts/perm-smoke-jnpf.sh`(18 条)⇒「面 B 覆盖 N/18」(当前 18/18)。 +- **单测**:`cargo test --workspace`。 +- **退出码约定一致**:`verify.sh` / `check-scaffold.py` / `pack-sync.py` / `perm-smoke*.sh` + 都是 `0` 成功 / `1` 运行期失败 / `2` 用法错。各脚本支持 `-h` / `--help`。 diff --git a/docs/contract.md b/docs/contract.md index 7aa3406..f69a823 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -721,7 +721,7 @@ SELECT row_to_json(q)::text AS _row FROM () AS q `parentId` 取 `f_parent_id`,为 NULL/空 ⇒ `'0'`) - 根按 `f_sort_code` 升序;同层 children 按 `f_sort_code` 升序 -### 8.4 种子菜单(8 行,`f_tenant_id='0'`,`f_enabled_mark=1`,`f_delete_mark=0`) +### 8.4 种子菜单(9 行,`f_tenant_id='0'`,`f_enabled_mark=1`,`f_delete_mark=0`) | id | fullName | urlAddress | parentId | type | icon | sortCode | |---|---|---|---|---|---|---| @@ -733,16 +733,18 @@ SELECT row_to_json(q)::text AS _row FROM () AS q | `m_demo` | Demo 示例 | `demo-item` | `0` | 2 | `app` | 6 | | `m_product` | 产品管理 | `shop/Product` | `0` | 2 | `app` | 7 | | `m_book` | 图书超市 | `books/Book` | `0` | 2 | `app` | 8 | +| `m_resource` | 数据资源 | `asset/DataResource` | `0` | 2 | `app` | 9 | **期望菜单树字符串**(冒烟断言用;值在**附录 A 的 `[MENU_TREE]` 区段**,脚本从那里读): ``` -系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市: +系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市:|数据资源: ``` -🔴 **这 8 行的值住在哪(分层红线 12)**: -- 前 5 行(系统管理 + 4 个系统页)= **平台层**的种子,值在 `platform/seed.rs` 的 `BUILTIN_MENUS`; -- 后 3 行(Demo / 产品 / 图书)= **业务层**的菜单,值在各自 `modules/.rs` 的 `*_MENU: MenuSpec`, - 经 `modules::ALL_MENUS` 交给装配根 `src/bootstrap.rs` 回灌。 +🔴 **这 9 行的值住在哪(分层红线 12)**: +- 前 5 行(系统管理 + 4 个系统页)= **平台**的种子,值在已发布的 `sspf` 包(`sspf-core` 的 `BUILTIN_MENUS`)—— + **不在本仓**; +- 后 4 行(Demo / 产品 / 图书 / 数据资源)= **业务包**的菜单,值在各自 `packs//src/lib.rs` 的 + `*_MENU: MenuSpec`,由 `sspf::Platform::packs(reg)` 带进两段式种子(**不用**再传给 `.menus()`)。 ⇒ **加一个业务模块只碰 `modules/`**(平台层一个字都不改),但**菜单行数会变** ⇒ 本节表格与 `modules::ALL_MENUS` 必须同步;`scripts/check-boundary.sh` 的 CP4/CP6 静态钉住这两处一致。 @@ -1056,7 +1058,7 @@ react 版 `scripts/perm-smoke.sh` 实际有 **32 条断言**。移植后一条 (冒烟脚本自带 `--enc` 的向量自检,**不**假设 node 存在。) - **JSON 取值** ⇒ `jq`(若已装)或 `python3`(macOS 自带)写的取字段小工具;**不得**用 node。 - **期望菜单树** ⇒ **从附录 A 的 `[MENU_TREE]` 区段读**(不是写死在脚本里)—— - 值仍是 §8.4 的 `系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市:`。 + 值仍是 §8.4 的 `系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市:|数据资源:`。 react 版是从 `src/backend/src/sys/seed.service.ts` 里 grep 菜单数组动态算的 —— 本仓是 Rust,没有那个文件 ⇒ 直接用字面量(§8.4 的表就是它的来源)。 - **后端地址** ⇒ `B` 环境变量,默认 **`http://127.0.0.1:30010`**(本仓端口,**不是** react 的 30000)。 @@ -1097,9 +1099,10 @@ m_menu 菜单管理 permission.menu system/Module m_sys 2 5 m_demo Demo 示例 permission.demo demo-item 0 2 app 6 m_product 产品管理 permission.shop.product shop/Product 0 2 app 7 m_book 图书超市 permission.books.book books/Book 0 2 app 8 +m_resource 数据资源 permission.asset.dataResource asset/DataResource 0 2 app 9 [MENU_TREE] -系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市: +系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市:|数据资源: [MODULE] # app entity table urlAddress moduleKey menuId apiFile rsFile @@ -1109,6 +1112,7 @@ m_book 图书超市 permission.books.book books/Book 0 2 app 8 demo DemoItem demo_item demo-item None m_demo 无 demo.rs shop Product shop_product shop/Product shop/Product m_product 有 shop.rs books Book book_shop_book books/Book books/Book m_book 有 books.rs +asset DataResource asset_data_resource asset/DataResource asset/DataResource m_resource 无 asset.rs [ENDPOINT] # face method path guard owner @@ -1148,10 +1152,13 @@ A DELETE /api/ssw/shop/Product/Delete shop/Product shop A GET /api/ssw/books/Book/List books/Book books A POST /api/ssw/books/Book/Save books/Book books A DELETE /api/ssw/books/Book/Delete books/Book books +A GET /api/ssw/asset/DataResource/List asset/DataResource asset +A POST /api/ssw/asset/DataResource/Save asset/DataResource asset +A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset [FACE] # face 条数 说明 -A 25 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 27 条) +A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) B 5 面 B 专属(官方 JNPF 形状) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) diff --git a/docs/known-limitations.md b/docs/known-limitations.md index 04a41ca..7d589f8 100644 --- a/docs/known-limitations.md +++ b/docs/known-limitations.md @@ -102,4 +102,4 @@ 🔴 **判别头只能是 `Vue-Version`**:官方前端发 `App-Code` / `Jnpf-Origin: pc` / `Vue-Version: 3` 三个头, 而本仓前端 `src/frontend/src/api/request.ts` **也发**前两个(与官方同款)⇒ **只有 `Vue-Version` 是本仓前端唯一不发的**。 🔴 **本仓前端禁止发 `Vue-Version`**(发了 ⇒ 面 A 请求被误判成面 B ⇒ 契约整体错位)。 -🔴 `scripts/check-module.sh` 的「全局红线」段**静态钉住两侧**:前端**禁发**该头 + 面 B 尺子**必带**该头。 +🔴 前端**禁发**该头(`src/frontend/src/api/request.ts`);面 B 尺子**必带**该头(`perm-smoke-jnpf.sh`)⇒ 两侧任一侧改了,另一把尺子立刻红。 diff --git a/docs/runbook.md b/docs/runbook.md index 25799fb..b05b792 100644 --- a/docs/runbook.md +++ b/docs/runbook.md @@ -172,137 +172,57 @@ B=http://127.0.0.1:30010 bash scripts/perm-smoke-jnpf.sh # 显式指定 ⇒ 列表项无 `password`/`secretkey` 且 `isAdministrator` 是**数字** · `ModuleBySystem` 返 `ListVO` · 授权写(官方完整 body)真落库 · 授权读是 **POST**。 -### 4.3 业务模块 10 接触点静态自检 +### 4.3 一键验收(推荐先跑这个) ```bash -bash scripts/check-module.sh # 无参 ⇒ 检查契约登记的全部业务模块(期望 PASS=93) -bash scripts/check-module.sh books Book # 只查一个 +bash scripts/verify.sh # 全量 7 步:pack-sync --check → check-scaffold → 自证 → cargo test → build → 两把尺子 +bash scripts/verify.sh --fast # 只静态 + 测试(4 步,不起服务) ``` -**纯静态**:不启动后端、不发请求、不依赖 node。 -每个 `appCode/Entity` 查 10 个接触点(后端路由注册 · spec 定义 · 实体表 · 守卫 `module_key` · -前端 api 文件 · 前端页面 · 前端路由 · **菜单声明**(`*_MENU: MenuSpec`,与契约 `[MENU]` 逐字对齐)· -**菜单登记**(`modules/mod.rs` 的 `ALL_MENUS`)· **三处一字不差**), -外加两条契约红线(`f_` 前缀 + `f_id VARCHAR(50)` 主键 · 软删契约)。 - -🔴 **期望值不在脚本里** —— 全部从 `docs/contract.md` **附录 A**(机器可读)读 -(`scripts/contract_expect.py` 解析):菜单表 / 业务模块清单 / 各尺子的断言条数。 -⇒ 改契约只改一处;代码漂移立刻报。 - -🔴 **尺子自证**:脚本结尾会比对「本尺子实际跑了多少条断言」与「契约登记的条数」, -对不上 ⇒ **失败**(防止有人删掉断言把尺子改弱)。 - -退出码:**0** 全过 / **1** 有 ❌ / **2** 用法错(未知参数、app_code/Entity 不在契约清单)。 - -> 🔴 demo 模块**没有** `api/demoitem.ts`(`views/DemoItem.tsx` 直接 `request.get('/ssw/demo/DemoItem/List')`) -> ⇒ 这一条走「view 直连」分支;两种都查不到才算 ❌。 - -### 4.4 分层红线静态自检(平台层 / 业务层不许互相渗透) +### 4.4 脚手架判据:本仓只准有业务(SC1–SC6) ```bash -bash scripts/check-boundary.sh # 期望:PASS=11 FAIL=0,退出码 0 +python3 scripts/check-scaffold.py # 期望:PASS=6 FAIL=0 +python3 scripts/check-scaffold.py --self-test # 期望:反自证 6/6 ``` -**纯静态**(只需要 `python3`,macOS 自带)。把 `CLAUDE.md` 红线 12 -(「加一个业务模块只碰业务层」)变成可执行的尺子: +平台(登录 / 权限 / 面 B / `base_*` / CRUD 引擎)在**已发布的 `sspf` 包**里,不在本仓。 +这条尺子钉的就是「别把平台抄回来」: | 判据 | 内容 | |---|---| -| **CP1'** | 扫描器**反自证** —— 造一个明知存在的泄漏,必须被抓到(永远返回「干净」的尺子 = 没有尺子) | -| **CP1** | 平台层**零业务标识符**(业务表名 / 实体名 / 路由前缀 / 菜单 id / url / en_code)—— 只扫**字符串字面量**(注释里的举例允许);禁止清单**从业务层自己派生** ⇒ 加模块时这把尺子自动变严 | -| **CP2** | 平台层**不反向依赖**业务层(`platform/**` 不许 `use crate::modules`) | -| **CP3** | 业务层**不直接调**平台层的种子(接线只在装配根 `bootstrap.rs`) | -| **CP4** | 每个业务模块必须声明 `*_MENU: MenuSpec` ⇒ 且被 `modules/mod.rs` 的 `ALL_MENUS` 收编 ⇒ 且声明的菜单 id 与**契约** `[MODULE]` 一致 | -| **CP5** | `platform::seed::ensure_base` 的调用点**只有** `bootstrap.rs`(应用与测试走同一条路 ⇒ 测到的库 == 上线的库) | -| **CP6** | 平台层自带菜单的**条数**(= 契约菜单数 − 业务模块数)与**id 列表**都与契约逐条一致(业务菜单不许混进 `platform/seed.rs`) | +| **SC1** | 本仓没有平台实现(`src/backend/src/platform/` · `routes.rs` · `bootstrap.rs` · `db/schema.sql` · `crates/`) | +| **SC2** | 业务侧没有 `base_*` 建表语句(`docs/` 里的参考 DDL 不算 —— 它不参与运行) | +| **SC3** | 应用 crate 只依赖门面 `sspf`(+ axum/tokio + 业务包),不直接依赖 `sspf-*` 内部 crate | +| **SC4** | 每个业务包只依赖 `sspf`,且 `Cargo.toml` / `pack.toml` / `schema/001_init.sql` / `src/lib.rs` 齐全 | +| **SC5** | `sspf` 只从 workspace 的 **git tag** 来;成员不许另写 `git` / `path` / `version` | +| **SC6** | 生成物与 `packs/*` 不漂移(复用 `pack-sync.py --check`) | -退出码:**0** 全过 / **1** 有 ❌ / **2** 用法错(缺 `python3`)。 +🔴 **反自证**:`--self-test` 给 6 条判据各造一个**真实违规**(抄回 `platform/`、写 +`CREATE TABLE base_user`、应用依赖 `sspf-core`、包依赖 `axum`、`sspf` 改成 path 依赖、 +改 `pack.toml` 让生成物漂移),断言**该条恰好变红**,且注入前基线全绿 —— +否则这条尺子就是「永远绿」的空壳。 -🔴 **期望值不在脚本里** —— 菜单数、业务模块数都从 `docs/contract.md` **附录 A** 读 -⇒ 加一个业务模块只需在契约里加两行,本脚本的期望值自动跟着变。 -🔴 **尺子自证**:结尾比对「实际跑了多少条断言」与「契约登记的条数」,对不上 ⇒ 失败。 - -### 4.5 契约端点表 ↔ 代码真实路由 对账(静态闸门 3) +### 4.5 生成物漂移(加包忘了跑 sync) ```bash -bash scripts/check-contract.sh # 期望:PASS=10 FAIL=0,退出码 0 +python3 scripts/pack-sync.py # 同步(幂等) +python3 scripts/pack-sync.py --check # 期望:✅ 4 个包 / 4 个模块,生成物无漂移 +python3 scripts/pack-sync.py --dry-run # 打印将要写入的内容 ``` -**纯静态**(只需要 `python3`)。把 `docs/contract.md` **附录 A 的 `[ENDPOINT]`** -(机器可读的端点表:face / method / path / guard / owner,一行一条,共 32 行) -与**代码里真实注册的路由**逐条对账 —— **双向**: +四处派生位置(都由 `packs/*` + `modules/*` 生成,**不许手改**): +`packs_gen.rs` 的 `GEN:PACKS` / `GEN:MANIFESTS`、`modules/mod.rs` 的五个段、 +应用 `Cargo.toml` 的 `GEN:PACK_DEPS`。 -| 判据 | 内容 | -|---|---| -| **CC2** | 端点**总数**一致(契约 N 条 == 代码 N 条) | -| **CC3** | 契约 → 代码:每条端点在代码里存在且**方法**一致 | -| **CC4** | 代码 → 契约:代码里没有契约未登记的端点 | -| **CC5** | **归属层**一致(`platform` / 业务模块代号 `demo|shop|books`) | -| **CC6** | **守卫**一致(面A 菜单 key / 面B 点权限编码 / 登录 / 无)—— **静态推导** | -| **CC7** | 钉子测试的字面量清单(`REGISTERED` / `JNPF_REGISTERED`)与平台层路由**双向覆盖** | -| **CC8** | 业务路由**三处**一致(各模块 `ROUTES` 常量 / `router()` 注册 / `ALL_ROUTES`) | -| **CC9** | 契约面计数**自洽**(`[FACE]` 登记的条数 == `[ENDPOINT]` 里各 face 的实际条数) | -| **CC10** | **官方端点台账**(`[OFFICIAL]`)↔ 代码真实路由**双向**:说 `implemented/partial` 的必须真的注册了,说 `absent/oos` 的必须**没有**注册;反向:**面 B / 共用**的每条路由都必须在台账上有账 | -| **CC1'** | **反自证** —— 注入 9 种已知漂移,必须**每一种**都被抓到 | - -退出码:**0** 全过 / **1** 有 ❌ / **2** 用法错或前置错误(契约读不出来)。 - -#### 官方端点覆盖 N/M(CC10 的副产物) - -尺子会打印一行进度(**不计入** PASS/FAIL): - -``` -📊 CC10-COVER:官方端点覆盖 8/47(implemented 3 / partial 5 / absent 39;oos 6 单列,不进分母) -``` - -N = `implemented` + `partial`(**已落地**的官方端点数); -M = 再加 `absent`(**在范围内**的官方端点总数,官方 JNPF 后台最小可用面这一条线); -`oos`(v1 明确不做:导入导出族、数据权限链接)**单列**,不进分母。 -状态词表见 `docs/contract.md` 附录 A `[OFFICIAL]` 的表头注释; -`partial` 的**具体偏差**逐条记在 `JNPF_COMPAT_SURFACE.md` §8 的 B1–B10。 - -🔴 台账的 `src` 列是官方出处 `文件:行号` ⇒ 由**引文闸门**(`check-citations.sh`)逐条核对 -⇒ 台账里的官方出处**不是抄来的**,是**验过的**。 - -🔴 **守卫对账是静态推导**(`require_module(&state,&headers,CONST)` ⇒ 菜单 key; -`guard(&state,&headers,EN_X)` ⇒ 点权限编码)⇒ 改守卫写法会让扫描器**推不出来** -(报 ⚠️ WARN,**不**判失败,但要人工核对)。 -🔴 **尺子自证**:结尾比对「实际跑了多少条断言」与「契约登记的条数」,对不上 ⇒ 失败。 -🔴 **改端点要改两处**:契约 §6 的散文表 **+** 附录 A 的 `[ENDPOINT]`。 - -### 4.6 文档引文(`路径:行号`)核对(静态闸门 4) +### 4.6 加/改业务包 ```bash -bash scripts/check-citations.sh # 期望:PASS=4 FAIL=0,退出码 0 -bash scripts/check-citations.sh --list # 顺带打印每条引文明细 +bash scripts/new-pack.sh blog Post --name "文章" --columns "title:VARCHAR(255),price:NUMERIC(12,2)" ``` -**纯静态**(只需要 `python3`)。本仓的文档大量引用源码位置,行号是**会漂移**的: -源码改一行 ⇒ 上游行号整体位移 ⇒ 文档里的引用**静默指向别的行**——不报错,只是悄悄说错话。 -本闸门把每条引文**解析到真实文件**并核对行号: - -| 判据 | 内容 | -|---|---| -| **CIT1** | 引文**可解析**:每条 `路径:行号` 都能定位到真实文件(当前 141 条) | -| **CIT2** | 引文**行号有效**:行号区间落在该文件的行数范围内(`N` / `N-M` / `N/M` / `N+` 四种写法) | -| **CIT3** | **DDL 行号表**对账:`CLAUDE.md` 里写的建表行号 ↔ 官方 DDL 那一行真的有 `CREATE TABLE <表名>`(7 张 `base_*` 表) | -| **CIT1'** | **反自证** —— 注入 3 类坏引用(行号越界 / 文件不存在 / DDL 行号错位),必须**每一种**都被抓到 | - -**解析口径**(三级,先精确后模糊):① `<根>/<路径>` 精确命中 ⇒ ② 相对路径**后缀**命中 -(`db/schema.sql` ⇒ `src/backend/db/schema.sql`)⇒ ③ **基名**命中(官方源码文档里 -`ActionResult.java:27` 这种写法)。参照根共 4 处:本仓 / 官方 JNPF 源码 -(`~/Desktop/workspace/jnpf`)/ react 姊妹技能 / cargo registry(引文指到依赖源码时,如 -`pglite-rs 0.2.7` 的 `src/db.rs:444`)。 - -退出码:**0** 全过 / **1** 有 ❌ / **2** 用法错或前置错误。 - -🔴 **外部参照根缺失 ⇒ 判「跳过」不判失败**(官方源码 / react 技能 / cargo registry 都不在本机时, -本闸门只校验本仓内的引文,条数照旧、状态记 ⏭)。 -🔴 **「无路径的续行行号」(`:NNN`)只报不判失败** —— 那是本仓表格的约定(先写文件名、 -下面只写行号),且**相邻两行可能指不同文件** ⇒ 机械继承会大量误报。 -本闸门用「上文 40 行内点名的文件里**任意一个**行数够」这种**弱判据**核对, -对不上才报「疑似漂移」。 -🔴 **尺子自证**:结尾比对「实际跑了多少条断言」与「契约登记的条数」,对不上 ⇒ 失败。 +建 `packs/blog/`(表 + 列 + 菜单 + 面 B 路由)+ `modules/blog.rs`(面 A),并自动跑生成。 +细节见 [`HOWTO_MODULE.md`](../HOWTO_MODULE.md)。 ### 4.7 macOS SysV 信号量回收(`cargo test` 跑多了会攒) diff --git a/packs/asset/Cargo.toml b/packs/asset/Cargo.toml new file mode 100644 index 0000000..1e3cac7 --- /dev/null +++ b/packs/asset/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "sspf-pack-asset" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 业务包只允许依赖平台门面 `sspf`(+ 纯数据结构 crate)。 +# 出现 axum / tokio / pglite ⇒ `scripts/check-scaffold.sh` 直接红。 +# 这是「整目录可搬走」的技术保证:包不碰平台内部 crate,也不碰源码仓。 +[dependencies] +sspf = { workspace = true } diff --git a/packs/asset/pack.toml b/packs/asset/pack.toml new file mode 100644 index 0000000..daeaf3a --- /dev/null +++ b/packs/asset/pack.toml @@ -0,0 +1,37 @@ +# 业务包清单 —— 与 `PLAN.md` §5.1 的格式一致。 +# 🔴 本文件不是给 cargo 读的,是给 `sspf pack export/import` 与内核装载器读的。 + +[pack] +app_code = "asset" +name = "数据资源" +version = "1.0.0" +kernel = ">=0.4,<0.5" # 内核兼容区间(不匹配则拒载) +migratable = true # 允许导出到基线平台 + +[pack.compat] +baseline = "v7" # 兼容基线版本 +frontend = "vue3" # 前端族(决定表单 JSON 方言) +tenant = false # 本期单租户 + +# 物理表:name = 本平台表名;baseline_table = 基线平台上的表名(允许不同,导出时映射) +[[pack.tables]] +name = "asset_data_resource" +ddl = "schema/001_init.sql" +baseline_table = "asset_data_resource" + +[pack.metadata] +# 低代码元数据(与基线平台 visualdev 同构的 JSON)。 +# P2 落地后这里会指向真实文件;现在留空表示「纯手写 spec,无元数据」。 +forms = [] +models = [] +menus = [] +flows = [] + +[pack.build] +# 纯元数据包(L0)⇒ 无 Rust 代码,不需要编译。 +# 若将来加 src/ 手写逻辑:kind = "static"(链进内核,编 30s); +# 要热插拔:kind = "dylib"(独立 .dylib,运行期装载)。 +# +# 🔴 kind 不是 "none" 时必须补 `toolchain = "1.95.0"`,且与 rust-toolchain.toml 一致。 +# 内核启动会校验 ABI 版本 + rustc 版本 + panic 策略,三者全对才装载(PLAN.md §4.5 铁律 4)。 +kind = "none" diff --git a/packs/asset/schema/001_init.sql b/packs/asset/schema/001_init.sql new file mode 100644 index 0000000..bc507e2 --- /dev/null +++ b/packs/asset/schema/001_init.sql @@ -0,0 +1,37 @@ +-- asset_data_resource —— 数据资源(业务包自带的 DDL)。 +-- +-- 🔴 **DDL 跟着包走**(批次 12 交付物 ③):本文件在 `packs/asset/schema/` 下, +-- 由 `packs/asset/src/lib.rs` 用 `include_str!` **编译进二进制** +-- ⇒ 内核启动时按包顺序幂等执行 ⇒ 不再手抄进 `db/schema.sql`。 +-- +-- 🔴 **【集成期友好性】列名按官方规范写**(见官方 +-- `jnpf-database/PostgreSQL/JNPF-PostgreSQL.sql` 的 `base_*` 表): +-- - `f_id VARCHAR(50)` —— 36 位 UUID(**不要限 32**); +-- - `f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL` —— **单租户也不许省**, +-- 官方 `base_*` 表全部带它,且参与复合主键 `(f_id, f_tenant_id)`; +-- - `f_delete_mark INTEGER DEFAULT 0` —— 软删标记。 +-- +-- 🔴 **列语义不许自创**:`f_name` / `f_category` / `f_scenario` / `f_provider` +-- / `f_format` / `f_scale` / `f_source` / `f_register_time` 取自公司本体 +-- `DataResource`(`数据资源`),**列名与列序逐字对齐本体** ⇒ 后续接本体平台 +-- 可直接映射,不用改表。 +-- +-- 🔴 **本文件只许建本包自己的表**,**不许建 `base_*`** —— 平台表的 DDL +-- 归 `db/schema.sql` 管(装载器会拦,见 `sspf-plugin` 的 `DdlTouchesBaseTable`)。 + +CREATE TABLE IF NOT EXISTS asset_data_resource ( + f_id VARCHAR(50) NOT NULL, + f_name VARCHAR(200), + f_category VARCHAR(50), + f_scenario VARCHAR(500), + f_provider VARCHAR(200), + f_format VARCHAR(50), + f_scale VARCHAR(50), + f_source VARCHAR(50), + f_register_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_mark INTEGER DEFAULT 0, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/packs/asset/src/lib.rs b/packs/asset/src/lib.rs new file mode 100644 index 0000000..f0a6a5f --- /dev/null +++ b/packs/asset/src/lib.rs @@ -0,0 +1,433 @@ +//! asset —— 数据资源业务包(**业务包样板**)。 +//! +//! 🔴 **这个 crate 是 P0 的核心验证物**:它只依赖 `sspf-sdk`, +//! 没有任何 axum / tokio / pglite / 内核代码 —— 却能声明完整的业务: +//! 实体(表 + 列 + 类型)、菜单、权限编码。 +//! +//! ⇒ 证明「业务包与平台剥离、可整目录搬走」在**依赖层面**成立。 +//! +//! ## 字段来源 +//! +//! 取自公司本体 `DataResource`(`数据资源`):名称 / 类别 / 应用场景 / 提供方 / +//! 格式 / 规模 / 来源 / 登记时间。**列名与列序逐字对齐本体** ⇒ 后续接本体平台 +//! 可直接映射,不用改表。 +//! +//! ## 与内核的接线 +//! +//! 内核侧只需一行: +//! ```ignore +//! let packs: Vec> = vec![Box::new(sspf_pack_asset::Pack)]; +//! ``` +//! +//! 🔴 **spec 的单一真源就是本文件**(批次 12 交付物 ②)—— +//! 内核的 `src/backend/src/modules/asset.rs` 只做 `pub use` 转发, +//! 不再保留第二份拷贝 ⇒ 改 spec 只改一处。 +//! +//! 🔴 **路由用官方 JNPF 形状**(`/api/{模块}/{资源}/…`)—— +//! **不是**面 A 的 `/api/ssw/{appCode}/{Entity}/{List|Save|Delete}` +//! (那是本仓自造的 ssw 约定 ⇒ 集成到官方 JNPF 时**全部作废**)。 +//! +//! 🔴 **DDL 跟着包走**(批次 12 交付物 ③)—— +//! `schema/001_init.sql` 用 `include_str!` **编译进二进制**, +//! 内核启动时按包顺序幂等执行 ⇒ 不再手抄进 `db/schema.sql`。 + +use sspf::{ + BusinessPack, ColumnSpec, EntitySpec, HttpMethod, Manifest, MenuSpec, PackRoute, RouteAction, + RouteGuard, +}; + +/// 🔴 **本包自带的 DDL**(编译进二进制 ⇒ 包目录可整目录搬走)。 +/// +/// 🔴 **含 `f_tenant_id`** —— 官方 `base_*` 表全部带它(`DEFAULT '0' NOT NULL` +/// 且参与复合主键 `(f_id, f_tenant_id)`),**单租户也不许省** +/// (集成时缺这一列 ⇒ 导不进官方)。 +pub const DATA_RESOURCE_DDL: &str = include_str!("../schema/001_init.sql"); + +/// 🔴 **包的统一 DDL 出口**(`表名 → DDL 文本`)—— 内核**只认这一种写法**。 +/// +/// 🔴 **为什么要有它**(批次 12.5): +/// 内核要把「每个包的 DDL」交给装载器(`sspf_plugin::PackDdl`), +/// 而 `include_str!` 的结果是**常量名**(本包叫 `DATA_RESOURCE_DDL`)。 +/// 若每个包的常量名都不同,内核就必须**逐包手写**「哪个常量对应哪张表」 +/// ⇒ 加包要改内核,且漏写只会表现为「表没建」⇒ **运行期才炸**。 +/// ⇒ 约定本常量:**名字固定、形状固定** ⇒ 内核/生成器可以无脑遍历。 +/// +/// 🔴 **为什么是 `&[(&str, &str)]` 而不是 `&[PackDdl]`**: +/// `PackDdl.sql` 是 `String`(运行期构造)⇒ 常量数组装不下; +/// 这里用 `&'static str` 对,由 `sspf_plugin::load_static` 在装载时转成 `PackDdl`。 +pub const DDLS: &[(&str, &str)] = &[("asset_data_resource", DATA_RESOURCE_DDL)]; + +/// `asset_data_resource` 的列清单(**顺序 = 响应 JSON 的键序**)。 +const DATA_RESOURCE_COLUMNS: &[ColumnSpec] = &[ + ColumnSpec { column: "f_id", json_key: "id", default: None, numeric: false }, + ColumnSpec { column: "f_name", json_key: "name", default: None, numeric: false }, + ColumnSpec { column: "f_category", json_key: "category", default: None, numeric: false }, + ColumnSpec { column: "f_scenario", json_key: "scenario", default: None, numeric: false }, + ColumnSpec { column: "f_provider", json_key: "provider", default: None, numeric: false }, + ColumnSpec { column: "f_format", json_key: "format", default: None, numeric: false }, + ColumnSpec { column: "f_scale", json_key: "scale", default: None, numeric: false }, + ColumnSpec { column: "f_source", json_key: "source", default: None, numeric: false }, + ColumnSpec { column: "f_register_time", json_key: "registerTime", default: None, numeric: false }, + ColumnSpec { column: "f_creator_user_id", json_key: "creatorUserId", default: None, numeric: false }, + ColumnSpec { column: "f_creator_time", json_key: "creatorTime", default: None, numeric: false }, + ColumnSpec { column: "f_delete_mark", json_key: "deleteMark", default: Some("0"), numeric: false }, + // 🔴 **【集成期友好性】`f_tenant_id` 不许省** —— 官方 `base_*` 表全部带它 + // (`VARCHAR(50) DEFAULT '0' NOT NULL`,参与复合主键 `(f_id, f_tenant_id)`)。 + // 单租户也不许省 ⇒ 集成时缺这一列 ⇒ **导不进官方**。 + ColumnSpec { column: "f_tenant_id", json_key: "tenantId", default: Some("0"), numeric: false }, +]; + +/// `asset_data_resource` 的 spec。 +pub const DATA_RESOURCE_SPEC: EntitySpec = EntitySpec { + app_code: "asset", + entity: "DataResource", + table: "asset_data_resource", + // 🔴 `module_key` 必须 == 菜单 `url_address` == 前端 Route path(三处一字不差)。 + module_key: Some("asset/DataResource"), + columns: DATA_RESOURCE_COLUMNS, + // 🔴 本体 `数据资源` 没有金额/计量字段 ⇒ 本包**无 numeric 列**。 + numeric_columns: &[], + // 非 demo 表 ⇒ `body.creatorUserId || 'admin'`。 + creator_fixed: None, +}; + +/// 本包的内置菜单。 +/// +/// 🔴 `url_address` 必须与 [`DATA_RESOURCE_SPEC`] 的 `module_key` 一字不差 —— +/// 面 A 的菜单守卫靠它命中。 +pub const DATA_RESOURCE_MENU: MenuSpec = MenuSpec { + id: "m_resource", + full_name: "数据资源", + // 本平台自定编码(基线平台无此模块)⇒ 面 B 的点权限判据 `f_en_code`。 + en_code: "permission.asset.dataResource", + url_address: "asset/DataResource", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 9, + // 🔴 字面量而非引用内核常量:业务包不许依赖内核(AR2)。 + // `mainSystem` 是基线平台的官方常量值,属于**契约字面量**,可以写死。 + system_en_code: "mainSystem", +}; + +/// 包清单(与 `pack.toml` 的 `[pack]` 段一致)。 +const MANIFEST: Manifest = Manifest { + app_code: "asset", + name: "数据资源", + version: "1.0.0", + kernel_req: ">=0.4,<0.5", + migratable: true, +}; + +// ---------------------------------------------------------------- 路由声明 +// +// 🔴 **【集成期友好性】路径必须是官方 JNPF 形状** —— +// 官方是 **RESTful**:`GET/POST /api/{模块}/{资源}` + `PUT/DELETE /api/{模块}/{资源}/{id}`, +// **不是**面 A 的 `/api/ssw/{appCode}/{Entity}/…`,**也不是**第三种「官方前缀 + ssw 动作后缀」 +// (`/api/asset/DataResource/List|Save|Delete`)。 +// +// 🔴 **为什么不能是「官方前缀 + 动作后缀」**(2026-11-02 实测官方源码,证据在下面): +// 扫 `~/Desktop/workspace/jnpf/jnpf-java-boot` 的全部 controller: +// - `/xxx/List` 端点 **GET 52 条 + POST 21 条** ⇒ **这个形状存在**; +// - `/xxx/Save` 端点 **只有 4 条**(低代码 / 打印 / AI 的特例)⇒ **不是 CRUD 通用形状**; +// - `/xxx/Delete` 端点 **0 条** ⇒ **根本不存在**。 +// ⇒ 官方 CRUD 的通用形状是 `GET /api/{模块}/{资源}`(列表) +// + `POST /api/{模块}/{资源}`(新建) +// + `PUT /api/{模块}/{资源}/{id}`(改) +// + `DELETE /api/{模块}/{资源}/{id}`(删)。 +// ⇒ **本包的路径按这个来** ⇒ 集成时**路径零改**(这才是护栏 8 的目的)。 +// +// 🔴 **路由是「声明」,不是 handler** —— `PackRoute` 里没有 axum 类型 +// ⇒ 业务包**不需要**依赖 axum(AR2/AR8 钉死)。 +// 内核按声明 + spec 生成真正的 handler(`platform::crud::crud_router`)。 + +/// `GET /api/asset/DataResource` —— 列表。 +pub const DATA_RESOURCE_LIST_ROUTE: PackRoute = PackRoute { + path: "/api/asset/DataResource", + method: HttpMethod::Get, + entity: "DataResource", + action: RouteAction::List, + // 🔴 **面 B 的判据 = 点权限(`f_en_code`)** —— 官方 `@SaCheckPermission` 的那套。 + // 面 A 的菜单路径(`f_url_address`)是**另一套**判据 ⇒ 两套并存,互不影响。 + guard: RouteGuard::EnCode("permission.asset.dataResource"), +}; + +/// `POST /api/asset/DataResource` —— 新建 / 更新(body 里带 `id` 就是更新)。 +pub const DATA_RESOURCE_SAVE_ROUTE: PackRoute = PackRoute { + path: "/api/asset/DataResource", + method: HttpMethod::Post, + entity: "DataResource", + action: RouteAction::Save, + guard: RouteGuard::EnCode("permission.asset.dataResource"), +}; + +/// `DELETE /api/asset/DataResource/{id}` —— 软删。 +pub const DATA_RESOURCE_DELETE_ROUTE: PackRoute = PackRoute { + path: "/api/asset/DataResource/{id}", + method: HttpMethod::Delete, + entity: "DataResource", + action: RouteAction::Delete, + guard: RouteGuard::EnCode("permission.asset.dataResource"), +}; + +/// 本包声明的全部路由。 +pub const DATA_RESOURCE_ROUTES: &[PackRoute] = &[ + DATA_RESOURCE_LIST_ROUTE, + DATA_RESOURCE_SAVE_ROUTE, + DATA_RESOURCE_DELETE_ROUTE, +]; + +/// 数据资源业务包。 +/// +/// 🔴 **类型名固定为 `Pack`**(批次 12.5)—— 内核的 `src/backend/src/packs_gen.rs` +/// 是**生成**的,生成器按 `sspf_pack_::Pack` 拼路径 +/// ⇒ 每个包都用同一个名字,加包才不用改内核。 +pub struct Pack; + +impl BusinessPack for Pack { + fn manifest(&self) -> &'static Manifest { + &MANIFEST + } + + fn entities(&self) -> &'static [EntitySpec] { + &[DATA_RESOURCE_SPEC] + } + + fn menus(&self) -> &'static [MenuSpec] { + &[DATA_RESOURCE_MENU] + } + + /// 🔴 **路由声明**(官方形状)—— 内核按它 + spec 生成 handler。 + fn routes(&self) -> &'static [PackRoute] { + DATA_RESOURCE_ROUTES + } + + // metadata() 留空:本包是「手写 spec」形态,没有低代码元数据。 + // P2 之后如果改用表单 JSON 驱动,在这里返回 `&["include_str!(...json)"]` 即可。 +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 🔴 三处一致:`module_key` == `menu.url_address`(第三处是前端 Route,本包管不到)。 + /// 不一致的后果是**静默放行**(菜单未映射 ⇒ 守卫不拦),不会报错。 + #[test] + fn module_key_matches_menu_url_address() { + let spec = &DATA_RESOURCE_SPEC; + assert_eq!(spec.module_key, Some(DATA_RESOURCE_MENU.url_address)); + } + + /// 列名全部 `f_` 前缀,且主键是 `f_id`。 + #[test] + fn columns_are_prefixed_and_have_id() { + assert_eq!(DATA_RESOURCE_COLUMNS[0].column, "f_id"); + for c in DATA_RESOURCE_COLUMNS { + assert!(c.column.starts_with("f_"), "列名必须 f_ 前缀: {}", c.column); + } + } + + /// `json_key` 必须是列名去 `f_` 前缀后的 camelCase(不能机械 snake→camel 猜)。 + #[test] + fn json_keys_are_camel_case_without_prefix() { + for c in DATA_RESOURCE_COLUMNS { + let stripped = c.column.trim_start_matches("f_"); + // 允许的差异只有下划线转驼峰 + let expect: String = { + let mut out = String::new(); + let mut up = false; + for ch in stripped.chars() { + if ch == '_' { + up = true; + } else if up { + out.extend(ch.to_uppercase()); + up = false; + } else { + out.push(ch); + } + } + out + }; + assert_eq!(c.json_key, expect, "json_key 与列名不匹配: {}", c.column); + } + } + + /// numeric 标记与 `numeric_columns` 必须一致(本包两者都空)。 + #[test] + fn numeric_columns_matches_column_flags() { + let flagged: Vec<&str> = DATA_RESOURCE_COLUMNS + .iter() + .filter(|c| c.numeric) + .map(|c| c.column) + .collect(); + assert_eq!(flagged, DATA_RESOURCE_SPEC.numeric_columns); + } + + /// 包清单与 spec 的 app_code 必须一致(否则内核按 app 路由会找不到)。 + #[test] + fn manifest_app_code_matches_spec() { + assert_eq!(Pack.manifest().app_code, DATA_RESOURCE_SPEC.app_code); + assert_eq!(Pack.entities().len(), 1); + assert_eq!(Pack.menus().len(), 1); + assert_eq!(Pack.routes().len(), 3); + } + + /// 🔴 **【集成期友好性】路由必须是官方形状** —— 面 A 的 `/api/ssw/...` + /// 在集成到官方 JNPF 时**全部作废** ⇒ 这里钉死。 + #[test] + fn routes_use_official_shape_not_face_a() { + for r in Pack.routes() { + assert!( + r.path.starts_with("/api/"), + "路由必须以 /api/ 开头: {}", + r.path + ); + assert!( + !r.path.starts_with("/api/ssw/"), + "🔴 路由不许用面 A 的 /api/ssw/...(集成时作废): {}", + r.path + ); + } + } + + /// 🔴 **路由的 entity 必须指向本包声明的实体** —— 否则装配时拿到空 spec + /// ⇒ 路由注册了但永远查不到表 ⇒ **静默 404**。 + #[test] + fn routes_point_at_declared_entities() { + let entities = Pack.entities(); + for r in Pack.routes() { + assert!( + entities.iter().any(|e| e.entity == r.entity), + "路由 {} 指向未声明的实体 {}", + r.path, + r.entity + ); + } + } + + /// 🔴 **动作与方法的对应**被钉死(内核的 `crud_router` 按这个分派)。 + #[test] + fn route_actions_match_methods() { + for r in Pack.routes() { + match (r.action, r.method) { + (RouteAction::List, HttpMethod::Get) => {} + (RouteAction::Save, HttpMethod::Post) => {} + (RouteAction::Delete, HttpMethod::Delete) => {} + _ => panic!( + "动作 {:?} 与方法 {:?} 的组合不被支持: {}", + r.action, + r.method, + r.path + ), + } + } + } + + /// 🔴 **路径必须是官方 RESTful 形状**(2026-11-02 实测官方源码定下的): + /// - 列表 ⇒ `GET /api/{模块}/{资源}` + /// - 新建 ⇒ `POST /api/{模块}/{资源}` + /// - 删除 ⇒ `DELETE /api/{模块}/{资源}/{id}` + /// + /// 🔴 **为什么 `/Save` + `/Delete` 后缀不许出现**(护栏 8 的真正含义): + /// 实测官方 `jnpf-java-boot` 的全部 controller: + /// `/xxx/List` GET 52 + POST 21(碰巧存在)、`/xxx/Save` **仅 4 条** + /// (低代码/打印/AI 的特例)、`/xxx/Delete` **0 条**(根本不存在)。 + /// ⇒ 用 ssw 动作后缀 = 集成时**必然要改路径** ⇒ 现在就拦。 + #[test] + fn routes_use_official_restful_shape() { + for r in Pack.routes() { + assert!( + !r.path.ends_with("/Save"), + "🔴 官方没有 /Save 这种 CRUD 端点(仅低代码特例): {}", + r.path + ); + assert!( + !r.path.ends_with("/Delete"), + "🔴 官方根本没有 /Delete 端点(0 条): {}", + r.path + ); + } + // 删除必须带 `{id}`(官方 RESTful 的删除是 `DELETE /api/{模块}/{资源}/{id}`)。 + let del = Pack + .routes() + .iter() + .find(|r| r.action == RouteAction::Delete) + .expect("必须有删除路由"); + assert!( + del.path.contains("{id}"), + "删除路由必须带 {{id}} 路径参数: {}", + del.path + ); + } + + /// 🔴 **守卫必须与菜单的 `f_en_code` 一字不差** —— 不一致 ⇒ + /// 运行时查菜单查不到 ⇒ 走「未映射放行」⇒ **任何登录用户都能调** ⇒ 静默越权。 + #[test] + fn route_guards_match_menu_en_code() { + for r in Pack.routes() { + let RouteGuard::EnCode(code) = r.guard else { + panic!("本包的路由都该有点权限守卫: {}", r.path); + }; + assert_eq!( + code, DATA_RESOURCE_MENU.en_code, + "路由 {} 的守卫与菜单的 f_en_code 不一致", + r.path + ); + } + } + + /// 🔴 **DDL 必须含 `f_tenant_id`**(官方 `base_*` 全部带它, + /// 参与复合主键 `(f_id, f_tenant_id)`)—— 集成时缺这列 ⇒ **导不进官方**。 + #[test] + fn ddl_carries_tenant_id() { + assert!(DATA_RESOURCE_DDL.contains("f_tenant_id"), "DDL 必须含 f_tenant_id"); + assert!( + DATA_RESOURCE_DDL.contains("PRIMARY KEY (f_id, f_tenant_id)"), + "复合主键必须是 (f_id, f_tenant_id)" + ); + } + + /// 🔴 **DDL 与 spec 的列必须一致** —— spec 少一列 ⇒ CRUD 投影会漏字段。 + #[test] + fn ddl_columns_match_spec_columns() { + for col in DATA_RESOURCE_SPEC.columns { + assert!( + DATA_RESOURCE_DDL.contains(col.column), + "DDL 缺列 {}(spec 里有,DDL 里没有)", + col.column + ); + } + } + + /// 🔴 **`DDLS` 的每一对都必须是「表名 → 真的建这张表的 SQL」**。 + /// + /// 🔴 写错表名的后果分两级: + /// - 与 `pack.toml` 的 `[[pack.tables]].name` 不一致 ⇒ 装载期报 + /// `DdlWithoutEntity`(响亮); + /// - 但 DDL **文本里**建的是另一张表 ⇒ 装载器不查这个 ⇒ 启动时建出来的表 + /// 与 spec 对不上 ⇒ **业务查询运行期才炸**(`relation does not exist`)。 + /// ⇒ 在包自己这一层就钉死,别指望上层。 + #[test] + fn ddls_pairs_name_the_table_they_create() { + assert!(!DDLS.is_empty(), "本包有实体 ⇒ DDLS 不能为空"); + for (table, sql) in DDLS { + assert!( + sql.contains(&format!("CREATE TABLE IF NOT EXISTS {table}")), + "DDLS 里 {table} 的 DDL 没有建这张表(表名与 SQL 不一致)" + ); + } + } + + /// 🔴 **`DDLS` 覆盖本包全部实体** —— 漏一张 ⇒ 那张表根本没建。 + #[test] + fn ddls_covers_every_entity_table() { + for spec in Pack.entities() { + assert!( + DDLS.iter().any(|(t, _)| *t == spec.table), + "实体 {} 的表 {} 不在 DDLS 里 ⇒ 不会建表", + spec.entity, + spec.table + ); + } + } +} diff --git a/packs/books/Cargo.toml b/packs/books/Cargo.toml new file mode 100644 index 0000000..5ee2336 --- /dev/null +++ b/packs/books/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "sspf-pack-books" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 业务包只允许依赖平台门面 `sspf`(+ 纯数据结构 crate)。 +# 出现 axum / tokio / pglite ⇒ `scripts/check-scaffold.sh` 直接红。 +# 这是「整目录可搬走」的技术保证:包不碰平台内部 crate,也不碰源码仓。 +[dependencies] +sspf = { workspace = true } diff --git a/packs/books/pack.toml b/packs/books/pack.toml new file mode 100644 index 0000000..f4bf316 --- /dev/null +++ b/packs/books/pack.toml @@ -0,0 +1,31 @@ +# 业务包清单 —— **示例包**(可整目录搬走,技能带它当样板)。 +# 🔴 本文件不是给 cargo 读的,是给 `sspf pack export/import` 与内核装载器读的。 + +[pack] +app_code = "books" +name = "图书超市" +version = "1.0.0" +kernel = ">=0.4,<0.5" # 契约版本区间(不是 cargo 版本,见 bootstrap::kernel_version) +migratable = true # 允许导出到基线平台 + +[pack.compat] +baseline = "react-demo" # 对齐基准 +frontend = "vue3" # 前端族(决定表单 JSON 方言) +tenant = false # 本期单租户(列仍带 f_tenant_id,见 DDL 注释) + +# 物理表:name = 本平台表名;baseline_table = 基线平台上的表名(导出时映射) +[[pack.tables]] +name = "book_shop_book" +ddl = "schema/001_init.sql" +baseline_table = "book_shop_book" + +[pack.metadata] +# 低代码元数据(与基线平台 visualdev 同构的 JSON)。纯手写 spec ⇒ 留空。 +forms = [] +models = [] +menus = [] +flows = [] + +[pack.build] +# 纯元数据包(L0):无 Rust 代码要编译,spec 直接链进内核。 +kind = "none" diff --git a/packs/books/schema/001_init.sql b/packs/books/schema/001_init.sql new file mode 100644 index 0000000..0ecdc11 --- /dev/null +++ b/packs/books/schema/001_init.sql @@ -0,0 +1,33 @@ +-- book_shop_book —— 图书超市(业务包自带的 DDL)。 +-- +-- 🔴 **DDL 跟着包走**:本文件在 `packs/books/schema/` 下,由 `packs/books/src/lib.rs` +-- 用 `include_str!` **编译进二进制** ⇒ 内核启动时按包顺序幂等执行 +-- ⇒ 不再手抄进 `db/schema.sql`。 +-- +-- 🔴 **列名 / 列序逐字对齐 react 版 TypeORM entity**(`books.entity.ts`)—— +-- 这是「两版后端能开同一个库」的前提 ⇒ **业务列一个都不许改名**。 +-- +-- 🔴 **2026-11-04 的两处差异**(搬成包时按平台规则补的,见 `HANDOFF.md`): +-- ① 追加 `f_tenant_id`(`DEFAULT '0' NOT NULL`)并进入复合主键 —— +-- 包 DDL 的硬闸门(`bootstrap::pack_ddls_carry_tenant_id_and_composite_key`) +-- 要求每张业务表都带它;react 侧不认识这一列,但读不读都行、写不写都行 +-- (有默认值),⇒ 同库兼容性仍然成立; +-- ② `f_id` 从 `PRIMARY KEY` 改成 `NOT NULL` + 末尾复合主键。 +-- 🔴 **spec 的列清单没有加 `f_tenant_id`** ⇒ 面 A / 面 B 的 JSON 键与响应**零变化**。 +-- +-- 🔴 **本文件只许建本包自己的表**,**不许建 `base_*`**(装载器会拦)。 + +CREATE TABLE IF NOT EXISTS book_shop_book ( + f_id VARCHAR(50) NOT NULL, + f_title VARCHAR(255), + f_author VARCHAR(100), + f_isbn VARCHAR(32), + f_category VARCHAR(50), + f_price NUMERIC(12,2), + f_stock INTEGER DEFAULT 0, + f_creator_user_id VARCHAR(50), + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_mark INTEGER DEFAULT 0, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/packs/books/src/lib.rs b/packs/books/src/lib.rs new file mode 100644 index 0000000..3e29b8d --- /dev/null +++ b/packs/books/src/lib.rs @@ -0,0 +1,229 @@ +//! books —— 图书超市业务包(**示例包**)。 +//! +// 🔴 **本包是「示例」,不是业务真源**:它演示「一个业务包只依赖 `sspf-sdk` +//! 就能声明完整的业务(表 + 列 + 菜单 + 面 B 路由)」。 +//! 技能把这套示例带走时,**整个 `packs/books` 目录一起搬**即可 —— 内核零改动。 +//! +//! 🔴 **依赖纪律(AR2)**:只允许 `sspf-sdk`。出现 axum / tokio / pglite +//! ⇒ `check-arch.sh` 直接红 —— 这是「整目录可搬走」的技术保证。 +//! 🔴 **守卫**:菜单 `books/Book`(`module_key`)⇒ 非管理员未授权 ⇒ `code=403`。 +//! 🔴 `f_price` 是 **numeric**(JSON 字符串 `"9.90"`)· `f_stock` 是 **int**(JSON 数字 `100`)。 +//! +//! 🔴 **DDL 跟着包走**:`schema/001_init.sql` 用 `include_str!` 编译进二进制, +//! 内核启动时幂等执行 ⇒ 不再手抄进 `db/schema.sql`。 + +use sspf::{ + BusinessPack, ColumnSpec, EntitySpec, HttpMethod, Manifest, MenuSpec, PackRoute, RouteAction, + RouteGuard, +}; + +/// 🔴 **本包自带的 DDL**(编译进二进制 ⇒ 包目录可整目录搬走)。 +pub const BOOK_DDL: &str = include_str!("../schema/001_init.sql"); + +/// 🔴 **包的统一 DDL 出口**(`表名 → DDL 文本`)—— 内核**只认这一种写法**。 +/// 常量名固定、形状固定 ⇒ 内核/生成器可以无脑遍历(加包不用改内核)。 +pub const DDLS: &[(&str, &str)] = &[("book_shop_book", BOOK_DDL)]; + +/// `book_shop_book` 的列清单(**顺序 = 响应 JSON 的键序**)。 +/// +/// 🔴 **不含 `f_tenant_id`**:该列在 DDL 里(平台硬要求),但不进投影 / 不进出参 +/// ⇒ 响应形状与面 A 的历史行为**逐字不变**(`db/schema.sql` 时代的 JSON 长什么样, +/// 现在还是什么样)。 +const BOOK_COLUMNS: &[ColumnSpec] = &[ + ColumnSpec { + column: "f_id", + json_key: "id", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_title", + json_key: "title", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_author", + json_key: "author", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_isbn", + json_key: "isbn", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_category", + json_key: "category", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_price", + json_key: "price", + default: Some("0.00"), + numeric: true, + }, + ColumnSpec { + column: "f_stock", + json_key: "stock", + default: Some("0"), + numeric: false, + }, + ColumnSpec { + column: "f_creator_user_id", + json_key: "creatorUserId", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_creator_time", + json_key: "creatorTime", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_delete_mark", + json_key: "deleteMark", + default: Some("0"), + numeric: false, + }, +]; + +/// `book_shop_book` 的 spec。 +pub const BOOK_SPEC: EntitySpec = EntitySpec { + app_code: "books", + entity: "Book", + table: "book_shop_book", + module_key: Some("books/Book"), + columns: BOOK_COLUMNS, + numeric_columns: &["f_price"], + creator_fixed: None, +}; + +/// 本包的内置菜单。 +/// +/// 🔴 `url_address` 与 [`BOOK_SPEC`] 的 `module_key` 必须**一字不差** +/// (面 A 的菜单守卫靠它命中);`module_key: None` 的包(如 demo)走「仅登录」。 +pub const BOOK_MENU: MenuSpec = MenuSpec { + id: "m_book", + full_name: "图书超市", + en_code: "permission.books.book", + url_address: "books/Book", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 8, + // 🔴 字面量而非引用内核常量:业务包不许依赖内核(AR2)。 + // `mainSystem` 是基线平台的官方常量值,属于契约字面量,可以写死。 + system_en_code: "mainSystem", +}; + +/// 包清单(与 `pack.toml` 的 `[pack]` 段一致)。 +const MANIFEST: Manifest = Manifest { + app_code: "books", + name: "图书超市", + version: "1.0.0", + kernel_req: ">=0.4,<0.5", + migratable: true, +}; + +// ---------------------------------------------------------------- 路由声明 +// +// 🔴 **面 B 必须是官方 RESTful 形状**:`GET/POST /api/{模块}/{资源}` + +// `DELETE /api/{模块}/{资源}/{id}` —— **不是**面 A 的 `/api/ssw/...`。 +// 面 A 由内核的 `src/backend/src/modules/books.rs` 提供(本仓自造约定)。 +// +// 🔴 **路由是「声明」,不是 handler** —— `PackRoute` 里没有 axum 类型 +// ⇒ 业务包不需要依赖 axum;内核按声明 + spec 生成真正的 handler +// (`sspf_core::crud::crud_router`)。 +// 🔴 **面 B 的判据 = 点权限(`f_en_code`)** —— 同上,与面 A 的菜单路径并存。 + +/// `GET /api/books/Book` —— 列表。 +pub const BOOK_LIST_ROUTE: PackRoute = PackRoute { + path: "/api/books/Book", + method: HttpMethod::Get, + entity: "Book", + action: RouteAction::List, + guard: RouteGuard::EnCode("permission.books.book"), +}; + +/// `POST /api/books/Book` —— 新建 / 更新(body 里带 `id` 就是更新)。 +pub const BOOK_SAVE_ROUTE: PackRoute = PackRoute { + path: "/api/books/Book", + method: HttpMethod::Post, + entity: "Book", + action: RouteAction::Save, + guard: RouteGuard::EnCode("permission.books.book"), +}; + +/// `DELETE /api/books/Book/{id}` —— 软删。 +pub const BOOK_DELETE_ROUTE: PackRoute = PackRoute { + path: "/api/books/Book/{id}", + method: HttpMethod::Delete, + entity: "Book", + action: RouteAction::Delete, + guard: RouteGuard::EnCode("permission.books.book"), +}; + +/// 本包声明的全部路由(每条实体恰好 3 条 —— 内核的装载自检钉住这个数)。 +pub const BOOK_ROUTES: &[PackRoute] = &[ + BOOK_LIST_ROUTE, + BOOK_SAVE_ROUTE, + BOOK_DELETE_ROUTE, +]; + +/// 业务包本体。 +/// +/// 🔴 **类型名固定为 `Pack`** —— 内核的 `packs_gen.rs` 是生成的, +/// 生成器按 `sspf_pack_::Pack` 拼路径 ⇒ 每个包都用同一个名字。 +pub struct Pack; + +impl BusinessPack for Pack { + fn manifest(&self) -> &'static Manifest { + &MANIFEST + } + + fn entities(&self) -> &'static [EntitySpec] { + &[BOOK_SPEC] + } + + fn menus(&self) -> &'static [MenuSpec] { + &[BOOK_MENU] + } + + fn routes(&self) -> &'static [PackRoute] { + BOOK_ROUTES + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 列名全部 `f_` 前缀,且第一列是 `f_id`(响应键序的第一位)。 + #[test] + fn columns_are_prefixed_and_have_id() { + assert_eq!(BOOK_COLUMNS[0].column, "f_id"); + for c in BOOK_COLUMNS { + assert!(c.column.starts_with("f_"), "列名必须 f_ 前缀: {}", c.column); + } + } + + /// spec 的 `module_key` 与菜单 `url_address` 一致(`None` 的包只校验菜单本身)。 + #[test] + fn module_key_matches_menu_url_address() { + match BOOK_SPEC.module_key { + Some(key) => assert_eq!(key, BOOK_MENU.url_address), + None => assert_eq!(BOOK_MENU.url_address, "books/Book"), + } + } + + /// 路由条数固定 3(List / Save / Delete)—— 少一条 ⇒ 某动作静默 404。 + #[test] + fn declares_exactly_three_routes() { + assert_eq!(BOOK_ROUTES.len(), 3); + } +} diff --git a/packs/demo/Cargo.toml b/packs/demo/Cargo.toml new file mode 100644 index 0000000..f2b5db0 --- /dev/null +++ b/packs/demo/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "sspf-pack-demo" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 业务包只允许依赖平台门面 `sspf`(+ 纯数据结构 crate)。 +# 出现 axum / tokio / pglite ⇒ `scripts/check-scaffold.sh` 直接红。 +# 这是「整目录可搬走」的技术保证:包不碰平台内部 crate,也不碰源码仓。 +[dependencies] +sspf = { workspace = true } diff --git a/packs/demo/pack.toml b/packs/demo/pack.toml new file mode 100644 index 0000000..a3eab42 --- /dev/null +++ b/packs/demo/pack.toml @@ -0,0 +1,31 @@ +# 业务包清单 —— **示例包**(可整目录搬走,技能带它当样板)。 +# 🔴 本文件不是给 cargo 读的,是给 `sspf pack export/import` 与内核装载器读的。 + +[pack] +app_code = "demo" +name = "Demo 示例" +version = "1.0.0" +kernel = ">=0.4,<0.5" # 契约版本区间(不是 cargo 版本,见 bootstrap::kernel_version) +migratable = true # 允许导出到基线平台 + +[pack.compat] +baseline = "react-demo" # 对齐基准 +frontend = "vue3" # 前端族(决定表单 JSON 方言) +tenant = false # 本期单租户(列仍带 f_tenant_id,见 DDL 注释) + +# 物理表:name = 本平台表名;baseline_table = 基线平台上的表名(导出时映射) +[[pack.tables]] +name = "demo_item" +ddl = "schema/001_init.sql" +baseline_table = "demo_item" + +[pack.metadata] +# 低代码元数据(与基线平台 visualdev 同构的 JSON)。纯手写 spec ⇒ 留空。 +forms = [] +models = [] +menus = [] +flows = [] + +[pack.build] +# 纯元数据包(L0):无 Rust 代码要编译,spec 直接链进内核。 +kind = "none" diff --git a/packs/demo/schema/001_init.sql b/packs/demo/schema/001_init.sql new file mode 100644 index 0000000..594dcb4 --- /dev/null +++ b/packs/demo/schema/001_init.sql @@ -0,0 +1,29 @@ +-- demo_item —— Demo 示例(业务包自带的 DDL)。 +-- +-- 🔴 **DDL 跟着包走**:本文件在 `packs/demo/schema/` 下,由 `packs/demo/src/lib.rs` +-- 用 `include_str!` **编译进二进制** ⇒ 内核启动时按包顺序幂等执行 +-- ⇒ 不再手抄进 `db/schema.sql`。 +-- +-- 🔴 **列名 / 列序逐字对齐 react 版 TypeORM entity**(`demo.entity.ts`)—— +-- 这是「两版后端能开同一个库」的前提 ⇒ **业务列一个都不许改名**。 +-- +-- 🔴 **2026-11-04 的两处差异**(搬成包时按平台规则补的,见 `HANDOFF.md`): +-- ① 追加 `f_tenant_id`(`DEFAULT '0' NOT NULL`)并进入复合主键 —— +-- 包 DDL 的硬闸门(`bootstrap::pack_ddls_carry_tenant_id_and_composite_key`) +-- 要求每张业务表都带它;react 侧不认识这一列,但读不读都行、写不写都行 +-- (有默认值),⇒ 同库兼容性仍然成立; +-- ② `f_id` 从 `PRIMARY KEY` 改成 `NOT NULL` + 末尾复合主键。 +-- 🔴 **spec 的列清单没有加 `f_tenant_id`** ⇒ 面 A / 面 B 的 JSON 键与响应**零变化**。 +-- +-- 🔴 **本文件只许建本包自己的表**,**不许建 `base_*`**(装载器会拦)。 + +CREATE TABLE IF NOT EXISTS demo_item ( + f_id VARCHAR(50) NOT NULL, + f_title VARCHAR(255), + f_status VARCHAR(32), + f_creator_user_id VARCHAR(50), + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_mark INTEGER DEFAULT 0, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/packs/demo/src/lib.rs b/packs/demo/src/lib.rs new file mode 100644 index 0000000..aad2b37 --- /dev/null +++ b/packs/demo/src/lib.rs @@ -0,0 +1,207 @@ +//! demo —— Demo 示例业务包(**示例包**)。 +//! +// 🔴 **本包是「示例」,不是业务真源**:它演示「一个业务包只依赖 `sspf-sdk` +//! 就能声明完整的业务(表 + 列 + 菜单 + 面 B 路由)」。 +//! 技能把这套示例带走时,**整个 `packs/demo` 目录一起搬**即可 —— 内核零改动。 +//! +//! 🔴 **依赖纪律(AR2)**:只允许 `sspf-sdk`。出现 axum / tokio / pglite +//! ⇒ `check-arch.sh` 直接红 —— 这是「整目录可搬走」的技术保证。 +//! 🔴 **本包的特别规则(裁决 S22)**:`f_creator_user_id` **恒为 `'admin'`** +//! (不看 body)⇒ 由 spec 的 `creator_fixed` 声明,引擎不认 app_code。 +//! 🔴 **本包仅登录**(`module_key: None`)⇒ 面 A 走「登录即可」,面 B 走 `RouteGuard::Login`。 +//! +//! 🔴 **DDL 跟着包走**:`schema/001_init.sql` 用 `include_str!` 编译进二进制, +//! 内核启动时幂等执行 ⇒ 不再手抄进 `db/schema.sql`。 + +use sspf::{ + BusinessPack, ColumnSpec, EntitySpec, HttpMethod, Manifest, MenuSpec, PackRoute, RouteAction, + RouteGuard, +}; + +/// 🔴 **本包自带的 DDL**(编译进二进制 ⇒ 包目录可整目录搬走)。 +pub const DEMO_DDL: &str = include_str!("../schema/001_init.sql"); + +/// 🔴 **包的统一 DDL 出口**(`表名 → DDL 文本`)—— 内核**只认这一种写法**。 +/// 常量名固定、形状固定 ⇒ 内核/生成器可以无脑遍历(加包不用改内核)。 +pub const DDLS: &[(&str, &str)] = &[("demo_item", DEMO_DDL)]; + +/// `demo_item` 的列清单(**顺序 = 响应 JSON 的键序**)。 +/// +/// 🔴 **不含 `f_tenant_id`**:该列在 DDL 里(平台硬要求),但不进投影 / 不进出参 +/// ⇒ 响应形状与面 A 的历史行为**逐字不变**(`db/schema.sql` 时代的 JSON 长什么样, +/// 现在还是什么样)。 +const DEMO_COLUMNS: &[ColumnSpec] = &[ + ColumnSpec { + column: "f_id", + json_key: "id", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_title", + json_key: "title", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_status", + json_key: "status", + default: Some("草稿"), + numeric: false, + }, + ColumnSpec { + column: "f_creator_user_id", + json_key: "creatorUserId", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_creator_time", + json_key: "creatorTime", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_delete_mark", + json_key: "deleteMark", + default: Some("0"), + numeric: false, + }, +]; + +/// `demo_item` 的 spec。 +pub const DEMO_SPEC: EntitySpec = EntitySpec { + app_code: "demo", + entity: "DemoItem", + table: "demo_item", + module_key: None, + columns: DEMO_COLUMNS, + numeric_columns: &[], + creator_fixed: Some("admin"), +}; + +/// 本包的内置菜单。 +/// +/// 🔴 `url_address` 与 [`DEMO_SPEC`] 的 `module_key` 必须**一字不差** +/// (面 A 的菜单守卫靠它命中);`module_key: None` 的包(如 demo)走「仅登录」。 +pub const DEMO_MENU: MenuSpec = MenuSpec { + id: "m_demo", + full_name: "Demo 示例", + en_code: "permission.demo", + url_address: "demo-item", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 6, + // 🔴 字面量而非引用内核常量:业务包不许依赖内核(AR2)。 + // `mainSystem` 是基线平台的官方常量值,属于契约字面量,可以写死。 + system_en_code: "mainSystem", +}; + +/// 包清单(与 `pack.toml` 的 `[pack]` 段一致)。 +const MANIFEST: Manifest = Manifest { + app_code: "demo", + name: "Demo 示例", + version: "1.0.0", + kernel_req: ">=0.4,<0.5", + migratable: true, +}; + +// ---------------------------------------------------------------- 路由声明 +// +// 🔴 **面 B 必须是官方 RESTful 形状**:`GET/POST /api/{模块}/{资源}` + +// `DELETE /api/{模块}/{资源}/{id}` —— **不是**面 A 的 `/api/ssw/...`。 +// 面 A 由内核的 `src/backend/src/modules/demo.rs` 提供(本仓自造约定)。 +// +// 🔴 **路由是「声明」,不是 handler** —— `PackRoute` 里没有 axum 类型 +// ⇒ 业务包不需要依赖 axum;内核按声明 + spec 生成真正的 handler +// (`sspf_core::crud::crud_router`)。 +// 🔴 **面 B 的守卫是 `Login`**:官方对 demo 这种「示例/工具类」端点不打 +// `@SaCheckPermission` ⇒ 登录即可。 + +/// `GET /api/demo/DemoItem` —— 列表。 +pub const DEMO_LIST_ROUTE: PackRoute = PackRoute { + path: "/api/demo/DemoItem", + method: HttpMethod::Get, + entity: "DemoItem", + action: RouteAction::List, + guard: RouteGuard::Login, +}; + +/// `POST /api/demo/DemoItem` —— 新建 / 更新(body 里带 `id` 就是更新)。 +pub const DEMO_SAVE_ROUTE: PackRoute = PackRoute { + path: "/api/demo/DemoItem", + method: HttpMethod::Post, + entity: "DemoItem", + action: RouteAction::Save, + guard: RouteGuard::Login, +}; + +/// `DELETE /api/demo/DemoItem/{id}` —— 软删。 +pub const DEMO_DELETE_ROUTE: PackRoute = PackRoute { + path: "/api/demo/DemoItem/{id}", + method: HttpMethod::Delete, + entity: "DemoItem", + action: RouteAction::Delete, + guard: RouteGuard::Login, +}; + +/// 本包声明的全部路由(每条实体恰好 3 条 —— 内核的装载自检钉住这个数)。 +pub const DEMO_ROUTES: &[PackRoute] = &[ + DEMO_LIST_ROUTE, + DEMO_SAVE_ROUTE, + DEMO_DELETE_ROUTE, +]; + +/// 业务包本体。 +/// +/// 🔴 **类型名固定为 `Pack`** —— 内核的 `packs_gen.rs` 是生成的, +/// 生成器按 `sspf_pack_::Pack` 拼路径 ⇒ 每个包都用同一个名字。 +pub struct Pack; + +impl BusinessPack for Pack { + fn manifest(&self) -> &'static Manifest { + &MANIFEST + } + + fn entities(&self) -> &'static [EntitySpec] { + &[DEMO_SPEC] + } + + fn menus(&self) -> &'static [MenuSpec] { + &[DEMO_MENU] + } + + fn routes(&self) -> &'static [PackRoute] { + DEMO_ROUTES + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 列名全部 `f_` 前缀,且第一列是 `f_id`(响应键序的第一位)。 + #[test] + fn columns_are_prefixed_and_have_id() { + assert_eq!(DEMO_COLUMNS[0].column, "f_id"); + for c in DEMO_COLUMNS { + assert!(c.column.starts_with("f_"), "列名必须 f_ 前缀: {}", c.column); + } + } + + /// spec 的 `module_key` 与菜单 `url_address` 一致(`None` 的包只校验菜单本身)。 + #[test] + fn module_key_matches_menu_url_address() { + match DEMO_SPEC.module_key { + Some(key) => assert_eq!(key, DEMO_MENU.url_address), + None => assert_eq!(DEMO_MENU.url_address, "demo-item"), + } + } + + /// 路由条数固定 3(List / Save / Delete)—— 少一条 ⇒ 某动作静默 404。 + #[test] + fn declares_exactly_three_routes() { + assert_eq!(DEMO_ROUTES.len(), 3); + } +} diff --git a/packs/shop/Cargo.toml b/packs/shop/Cargo.toml new file mode 100644 index 0000000..68e747b --- /dev/null +++ b/packs/shop/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "sspf-pack-shop" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 业务包只允许依赖平台门面 `sspf`(+ 纯数据结构 crate)。 +# 出现 axum / tokio / pglite ⇒ `scripts/check-scaffold.sh` 直接红。 +# 这是「整目录可搬走」的技术保证:包不碰平台内部 crate,也不碰源码仓。 +[dependencies] +sspf = { workspace = true } diff --git a/packs/shop/pack.toml b/packs/shop/pack.toml new file mode 100644 index 0000000..a9e998b --- /dev/null +++ b/packs/shop/pack.toml @@ -0,0 +1,31 @@ +# 业务包清单 —— **示例包**(可整目录搬走,技能带它当样板)。 +# 🔴 本文件不是给 cargo 读的,是给 `sspf pack export/import` 与内核装载器读的。 + +[pack] +app_code = "shop" +name = "产品管理" +version = "1.0.0" +kernel = ">=0.4,<0.5" # 契约版本区间(不是 cargo 版本,见 bootstrap::kernel_version) +migratable = true # 允许导出到基线平台 + +[pack.compat] +baseline = "react-demo" # 对齐基准 +frontend = "vue3" # 前端族(决定表单 JSON 方言) +tenant = false # 本期单租户(列仍带 f_tenant_id,见 DDL 注释) + +# 物理表:name = 本平台表名;baseline_table = 基线平台上的表名(导出时映射) +[[pack.tables]] +name = "shop_product" +ddl = "schema/001_init.sql" +baseline_table = "shop_product" + +[pack.metadata] +# 低代码元数据(与基线平台 visualdev 同构的 JSON)。纯手写 spec ⇒ 留空。 +forms = [] +models = [] +menus = [] +flows = [] + +[pack.build] +# 纯元数据包(L0):无 Rust 代码要编译,spec 直接链进内核。 +kind = "none" diff --git a/packs/shop/schema/001_init.sql b/packs/shop/schema/001_init.sql new file mode 100644 index 0000000..e8be836 --- /dev/null +++ b/packs/shop/schema/001_init.sql @@ -0,0 +1,29 @@ +-- shop_product —— 产品管理(业务包自带的 DDL)。 +-- +-- 🔴 **DDL 跟着包走**:本文件在 `packs/shop/schema/` 下,由 `packs/shop/src/lib.rs` +-- 用 `include_str!` **编译进二进制** ⇒ 内核启动时按包顺序幂等执行 +-- ⇒ 不再手抄进 `db/schema.sql`。 +-- +-- 🔴 **列名 / 列序逐字对齐 react 版 TypeORM entity**(`shop.entity.ts`)—— +-- 这是「两版后端能开同一个库」的前提 ⇒ **业务列一个都不许改名**。 +-- +-- 🔴 **2026-11-04 的两处差异**(搬成包时按平台规则补的,见 `HANDOFF.md`): +-- ① 追加 `f_tenant_id`(`DEFAULT '0' NOT NULL`)并进入复合主键 —— +-- 包 DDL 的硬闸门(`bootstrap::pack_ddls_carry_tenant_id_and_composite_key`) +-- 要求每张业务表都带它;react 侧不认识这一列,但读不读都行、写不写都行 +-- (有默认值),⇒ 同库兼容性仍然成立; +-- ② `f_id` 从 `PRIMARY KEY` 改成 `NOT NULL` + 末尾复合主键。 +-- 🔴 **spec 的列清单没有加 `f_tenant_id`** ⇒ 面 A / 面 B 的 JSON 键与响应**零变化**。 +-- +-- 🔴 **本文件只许建本包自己的表**,**不许建 `base_*`**(装载器会拦)。 + +CREATE TABLE IF NOT EXISTS shop_product ( + f_id VARCHAR(50) NOT NULL, + f_title VARCHAR(255), + f_price NUMERIC(12,2), + f_creator_user_id VARCHAR(50), + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_mark INTEGER DEFAULT 0, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/packs/shop/src/lib.rs b/packs/shop/src/lib.rs new file mode 100644 index 0000000..3b2e949 --- /dev/null +++ b/packs/shop/src/lib.rs @@ -0,0 +1,206 @@ +//! shop —— 产品管理业务包(**示例包**)。 +//! +// 🔴 **本包是「示例」,不是业务真源**:它演示「一个业务包只依赖 `sspf-sdk` +//! 就能声明完整的业务(表 + 列 + 菜单 + 面 B 路由)」。 +//! 技能把这套示例带走时,**整个 `packs/shop` 目录一起搬**即可 —— 内核零改动。 +//! +//! 🔴 **依赖纪律(AR2)**:只允许 `sspf-sdk`。出现 axum / tokio / pglite +//! ⇒ `check-arch.sh` 直接红 —— 这是「整目录可搬走」的技术保证。 +//! 🔴 **守卫**:菜单 `shop/Product`(`module_key`)⇒ 非管理员未授权 ⇒ `code=403`。 +//! 🔴 `f_price` 是 **numeric**(JSON 字符串 `"9.90"`)⇒ 进 `numeric_columns`。 +//! +//! 🔴 **DDL 跟着包走**:`schema/001_init.sql` 用 `include_str!` 编译进二进制, +//! 内核启动时幂等执行 ⇒ 不再手抄进 `db/schema.sql`。 + +use sspf::{ + BusinessPack, ColumnSpec, EntitySpec, HttpMethod, Manifest, MenuSpec, PackRoute, RouteAction, + RouteGuard, +}; + +/// 🔴 **本包自带的 DDL**(编译进二进制 ⇒ 包目录可整目录搬走)。 +pub const PRODUCT_DDL: &str = include_str!("../schema/001_init.sql"); + +/// 🔴 **包的统一 DDL 出口**(`表名 → DDL 文本`)—— 内核**只认这一种写法**。 +/// 常量名固定、形状固定 ⇒ 内核/生成器可以无脑遍历(加包不用改内核)。 +pub const DDLS: &[(&str, &str)] = &[("shop_product", PRODUCT_DDL)]; + +/// `shop_product` 的列清单(**顺序 = 响应 JSON 的键序**)。 +/// +/// 🔴 **不含 `f_tenant_id`**:该列在 DDL 里(平台硬要求),但不进投影 / 不进出参 +/// ⇒ 响应形状与面 A 的历史行为**逐字不变**(`db/schema.sql` 时代的 JSON 长什么样, +/// 现在还是什么样)。 +const PRODUCT_COLUMNS: &[ColumnSpec] = &[ + ColumnSpec { + column: "f_id", + json_key: "id", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_title", + json_key: "title", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_price", + json_key: "price", + default: Some("0.00"), + numeric: true, + }, + ColumnSpec { + column: "f_creator_user_id", + json_key: "creatorUserId", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_creator_time", + json_key: "creatorTime", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_delete_mark", + json_key: "deleteMark", + default: Some("0"), + numeric: false, + }, +]; + +/// `shop_product` 的 spec。 +pub const PRODUCT_SPEC: EntitySpec = EntitySpec { + app_code: "shop", + entity: "Product", + table: "shop_product", + module_key: Some("shop/Product"), + columns: PRODUCT_COLUMNS, + numeric_columns: &["f_price"], + creator_fixed: None, +}; + +/// 本包的内置菜单。 +/// +/// 🔴 `url_address` 与 [`PRODUCT_SPEC`] 的 `module_key` 必须**一字不差** +/// (面 A 的菜单守卫靠它命中);`module_key: None` 的包(如 demo)走「仅登录」。 +pub const PRODUCT_MENU: MenuSpec = MenuSpec { + id: "m_product", + full_name: "产品管理", + en_code: "permission.shop.product", + url_address: "shop/Product", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 7, + // 🔴 字面量而非引用内核常量:业务包不许依赖内核(AR2)。 + // `mainSystem` 是基线平台的官方常量值,属于契约字面量,可以写死。 + system_en_code: "mainSystem", +}; + +/// 包清单(与 `pack.toml` 的 `[pack]` 段一致)。 +const MANIFEST: Manifest = Manifest { + app_code: "shop", + name: "产品管理", + version: "1.0.0", + kernel_req: ">=0.4,<0.5", + migratable: true, +}; + +// ---------------------------------------------------------------- 路由声明 +// +// 🔴 **面 B 必须是官方 RESTful 形状**:`GET/POST /api/{模块}/{资源}` + +// `DELETE /api/{模块}/{资源}/{id}` —— **不是**面 A 的 `/api/ssw/...`。 +// 面 A 由内核的 `src/backend/src/modules/shop.rs` 提供(本仓自造约定)。 +// +// 🔴 **路由是「声明」,不是 handler** —— `PackRoute` 里没有 axum 类型 +// ⇒ 业务包不需要依赖 axum;内核按声明 + spec 生成真正的 handler +// (`sspf_core::crud::crud_router`)。 +// 🔴 **面 B 的判据 = 点权限(`f_en_code`)** —— 官方 `@SaCheckPermission` 那套; +// 面 A 的菜单路径(`f_url_address`)是另一套判据 ⇒ 两套并存,互不影响。 + +/// `GET /api/shop/Product` —— 列表。 +pub const PRODUCT_LIST_ROUTE: PackRoute = PackRoute { + path: "/api/shop/Product", + method: HttpMethod::Get, + entity: "Product", + action: RouteAction::List, + guard: RouteGuard::EnCode("permission.shop.product"), +}; + +/// `POST /api/shop/Product` —— 新建 / 更新(body 里带 `id` 就是更新)。 +pub const PRODUCT_SAVE_ROUTE: PackRoute = PackRoute { + path: "/api/shop/Product", + method: HttpMethod::Post, + entity: "Product", + action: RouteAction::Save, + guard: RouteGuard::EnCode("permission.shop.product"), +}; + +/// `DELETE /api/shop/Product/{id}` —— 软删。 +pub const PRODUCT_DELETE_ROUTE: PackRoute = PackRoute { + path: "/api/shop/Product/{id}", + method: HttpMethod::Delete, + entity: "Product", + action: RouteAction::Delete, + guard: RouteGuard::EnCode("permission.shop.product"), +}; + +/// 本包声明的全部路由(每条实体恰好 3 条 —— 内核的装载自检钉住这个数)。 +pub const PRODUCT_ROUTES: &[PackRoute] = &[ + PRODUCT_LIST_ROUTE, + PRODUCT_SAVE_ROUTE, + PRODUCT_DELETE_ROUTE, +]; + +/// 业务包本体。 +/// +/// 🔴 **类型名固定为 `Pack`** —— 内核的 `packs_gen.rs` 是生成的, +/// 生成器按 `sspf_pack_::Pack` 拼路径 ⇒ 每个包都用同一个名字。 +pub struct Pack; + +impl BusinessPack for Pack { + fn manifest(&self) -> &'static Manifest { + &MANIFEST + } + + fn entities(&self) -> &'static [EntitySpec] { + &[PRODUCT_SPEC] + } + + fn menus(&self) -> &'static [MenuSpec] { + &[PRODUCT_MENU] + } + + fn routes(&self) -> &'static [PackRoute] { + PRODUCT_ROUTES + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 列名全部 `f_` 前缀,且第一列是 `f_id`(响应键序的第一位)。 + #[test] + fn columns_are_prefixed_and_have_id() { + assert_eq!(PRODUCT_COLUMNS[0].column, "f_id"); + for c in PRODUCT_COLUMNS { + assert!(c.column.starts_with("f_"), "列名必须 f_ 前缀: {}", c.column); + } + } + + /// spec 的 `module_key` 与菜单 `url_address` 一致(`None` 的包只校验菜单本身)。 + #[test] + fn module_key_matches_menu_url_address() { + match PRODUCT_SPEC.module_key { + Some(key) => assert_eq!(key, PRODUCT_MENU.url_address), + None => assert_eq!(PRODUCT_MENU.url_address, "shop/Product"), + } + } + + /// 路由条数固定 3(List / Save / Delete)—— 少一条 ⇒ 某动作静默 404。 + #[test] + fn declares_exactly_three_routes() { + assert_eq!(PRODUCT_ROUTES.len(), 3); + } +} diff --git a/scripts/check-boundary-scan.py b/scripts/check-boundary-scan.py deleted file mode 100644 index bd954db..0000000 --- a/scripts/check-boundary-scan.py +++ /dev/null @@ -1,246 +0,0 @@ -#!/usr/bin/env python3 -"""check-boundary-scan.py —— 平台层「零业务知识」扫描器(`check-boundary.sh` 的 CP1 后端)。 - -🔴 **为什么需要它**:CLAUDE.md 红线 12 要求「加一个业务模块只碰业务层」 - ⇒ 平台层(`src/backend/src/platform/`)里**不许出现任何业务标识符** - (业务表名 / 实体名 / 路由前缀 / 菜单 id / 菜单 url / 菜单 en_code)。 - 这条规则**只靠人看代码守不住** —— 加模块的人不会主动去看平台层 ⇒ 需要一把尺子。 - -🔴 **禁止的标识符清单从业务层自己派生**(不是手写常量表): - 业务层说了什么 ⇒ 平台层就不许出现什么 ⇒ **加一个业务模块,这把尺子自动变严**, - 不会出现「忘了同步常量表 ⇒ 漏检」。 - -🔴 **只扫「字符串字面量」**(注释不算): - 注释里举例说明业务名是**文档行为**(例如解释 CTE 作用域)⇒ 允许; - 代码里出现业务标识符才是**耦合** ⇒ 拦。 - -用法: - python3 scripts/check-boundary-scan.py [...] - -退出码: - 0 = 干净(平台层零业务标识符) - 1 = 发现泄漏(逐条打印 `文件:行号: [种类] token`) - 2 = 用法错 -""" - -import os -import re -import sys - -# 🔴 业务层里「哪些字段是业务知识」的抽取规则(与 `EntitySpec` / `MenuSpec` 的字段名对齐)。 -SPEC_TABLE_RE = re.compile(r'table:\s*"([^"]+)"') -SPEC_ENTITY_RE = re.compile(r'entity:\s*"([^"]+)"') -SPEC_APP_RE = re.compile(r'app_code:\s*"([^"]+)"') -MENU_BLOCK_RE = re.compile(r'MenuSpec\s*\{(.*?)\n\};', re.DOTALL) -MENU_FIELD_RE = { - # 🔴 `\b` 不可省:否则 `parent_id: "0"` 里的 `id:` 会被当成菜单 id。 - "id": re.compile(r'\bid:\s*"([^"]+)"'), - "en_code": re.compile(r'\ben_code:\s*"([^"]+)"'), - "url_address": re.compile(r'\burl_address:\s*"([^"]+)"'), -} - -# 🔴 字符串字面量:`r#"..."#` / `r"..."` / `"..."`(普通串的转义 `\"` 不影响子串判定)。 -LITERAL_RE = re.compile(r'r(#*)"(.*?)"\1|"((?:[^"\\]|\\.)*)"', re.DOTALL) - - -def strip_comments(src): - """去掉 `//` 行注释与 `/* */` 块注释(保留字符串字面量里的内容)。 - - 🔴 逐字符扫描 ⇒ 字符串里的 `//`(如 `"http://x"`)不会被误当注释。 - """ - out = [] - in_block = False - for line in src.splitlines(): - if in_block: - end = line.find("*/") - if end == -1: - continue - line = line[end + 2:] - in_block = False - buf = [] - in_str = False - i = 0 - n = len(line) - while i < n: - c = line[i] - if in_str: - buf.append(c) - if c == "\\" and i + 1 < n: - buf.append(line[i + 1]) - i += 2 - continue - if c == '"': - in_str = False - i += 1 - continue - if c == '"': - in_str = True - buf.append(c) - i += 1 - continue - if line.startswith("//", i): - break - if line.startswith("/*", i): - in_block = True - rest = line[i + 2:] - end = rest.find("*/") - if end == -1: - break - line = rest[end + 2:] - buf = [] - i = 0 - n = len(line) - in_str = False - continue - buf.append(c) - i += 1 - out.append("".join(buf)) - return out - - -def literals_with_lines(path): - """⇒ [(行号, 字面量内容)](注释已剔除)。""" - with open(path, "r", encoding="utf-8") as fh: - lines = strip_comments(fh.read()) - out = [] - for idx, line in enumerate(lines, start=1): - for m in LITERAL_RE.finditer(line): - content = m.group(2) if m.group(1) is not None else m.group(3) - if content is not None: - out.append((idx, content)) - return out - - -def business_tokens(modules_dir): - """从业务层派生「平台层不许出现」的标识符清单。 - - ⇒ [(种类, token)],种类用于报错时点名「漏的是哪一类」。 - """ - tokens = [] - seen = set() - - def add(kind, value): - if not value: - return - key = (kind, value) - if key in seen: - return - seen.add(key) - tokens.append((kind, value)) - - for name in sorted(os.listdir(modules_dir)): - if not name.endswith(".rs") or name == "mod.rs": - continue - path = os.path.join(modules_dir, name) - with open(path, "r", encoding="utf-8") as fh: - src = "\n".join(strip_comments(fh.read())) - for m in SPEC_TABLE_RE.finditer(src): - add("业务表名", m.group(1)) - for m in SPEC_ENTITY_RE.finditer(src): - add("业务实体名", m.group(1)) - for m in SPEC_APP_RE.finditer(src): - add("业务路由前缀", "/api/ssw/{}/".format(m.group(1))) - for m in MENU_BLOCK_RE.finditer(src): - body = m.group(1) - for kind, rx in MENU_FIELD_RE.items(): - for f in rx.finditer(body): - add("业务菜单 {}".format(kind), f.group(1)) - return tokens - - -def rust_files(root): - """⇒ root 下全部 `.rs` 文件(递归,按路径排序)。""" - out = [] - for dirpath, dirnames, filenames in os.walk(root): - dirnames.sort() - for name in sorted(filenames): - if name.endswith(".rs"): - out.append(os.path.join(dirpath, name)) - return out - - -def main(argv): - if len(argv) >= 2 and argv[1] == "--self-test": - return self_test() - - if len(argv) < 3: - sys.stderr.write( - "用法: python3 scripts/check-boundary-scan.py [...]\n" - ) - return 2 - - modules_dir = argv[1] - scan_dirs = argv[2:] - tokens = business_tokens(modules_dir) - if not tokens: - sys.stderr.write("业务层没解析出任何标识符(modules_dir 有问题?)\n") - return 2 - - violations = [] - scanned = 0 - for root in scan_dirs: - for path in rust_files(root): - scanned += 1 - rel = os.path.relpath(path) - for lineno, content in literals_with_lines(path): - for kind, token in tokens: - if token in content: - violations.append((rel, lineno, kind, token, content.strip())) - - for rel, lineno, kind, token, content in violations: - print("{}:{}: [{}] {} ← 字面量: {}".format(rel, lineno, kind, token, content[:120])) - - print("scanned_files={} tokens={} violations={}".format(scanned, len(tokens), len(violations))) - return 1 if violations else 0 - - -def self_test(): - """🔴 **反自证**:造一个「平台层泄漏业务表名」的假文件 ⇒ 必须被抓出来。 - - 🔴 **为什么必须有**:一把永远返回「干净」的尺子 = 没有尺子。 - 自证 = 用同一条规则去抓一个**明知存在**的泄漏 ⇒ 抓到了 ⇒ 规则本身有效。 - """ - import tempfile - - with tempfile.TemporaryDirectory() as tmp: - mods = os.path.join(tmp, "modules") - plat = os.path.join(tmp, "platform") - os.makedirs(mods) - os.makedirs(plat) - with open(os.path.join(mods, "demo.rs"), "w", encoding="utf-8") as fh: - fh.write( - 'pub const DEMO_SPEC: EntitySpec = EntitySpec {\n' - ' app_code: "demo",\n' - ' entity: "DemoItem",\n' - ' table: "demo_item",\n' - '};\n' - ) - # 泄漏:平台层里出现了业务表名(**在字符串字面量里**)。 - with open(os.path.join(plat, "leak.rs"), "w", encoding="utf-8") as fh: - fh.write('const SQL: &str = "SELECT * FROM demo_item";\n') - # 不泄漏:只在**注释**里提到业务表名(文档行为,允许)。 - with open(os.path.join(plat, "doc.rs"), "w", encoding="utf-8") as fh: - fh.write('// 例:SELECT * FROM demo_item\nconst OK: &str = "SELECT 1";\n') - - tokens = business_tokens(mods) - # 表名 + 实体名 + 路由前缀(假 spec 里没有 MenuSpec ⇒ 没有菜单那三类)。 - if len(tokens) != 3: - print("self-test: token 抽取数不对: {}".format(len(tokens))) - return 1 - - hits = 0 - for path in rust_files(plat): - for _lineno, content in literals_with_lines(path): - for _kind, token in tokens: - if token in content: - hits += 1 - if hits != 1: - print("self-test: 应恰好抓到 1 处泄漏,实际 {} 处".format(hits)) - return 1 - - print("self-test: OK(泄漏被抓到、注释里的举例未被误报)") - return 0 - - -if __name__ == "__main__": - sys.exit(main(sys.argv)) \ No newline at end of file diff --git a/scripts/check-boundary.sh b/scripts/check-boundary.sh deleted file mode 100755 index e506bcb..0000000 --- a/scripts/check-boundary.sh +++ /dev/null @@ -1,268 +0,0 @@ -#!/usr/bin/env bash -# ssw-jnpf-lite-rust 分层红线自检 —— 「平台层 / 业务层」不许互相渗透 -# -# 目的:把 CLAUDE.md **红线 12**(「加一个业务模块只碰业务层」)变成**可执行的尺子**。 -# 这条红线靠人读代码守不住 —— 加模块的人不会主动去看平台层 ⇒ 必须自动查。 -# -# 🔴 **纯静态**:不启动后端、不发请求。只需要 `python3`(macOS 自带)。 -# -# 用法: -# bash scripts/check-boundary.sh # 无参 ⇒ 全查 -# bash scripts/check-boundary.sh --help # 本用法 -# -# 退出码:0 全过 / 1 有 ❌ 项 / 2 用法错 -# -# ── 判据 ── -# CP1 平台层零业务标识符(业务表名 / 实体名 / 路由前缀 / 菜单 id / url / en_code) -# —— 只扫**字符串字面量**(注释里举例说明业务名是文档行为,允许) -# —— 禁止清单**从业务层自己派生** ⇒ 加模块时这把尺子自动变严 -# CP1' 扫描器**反自证**:造一个明知存在的泄漏 ⇒ 必须被抓到(永远返回「干净」的尺子 = 没有尺子) -# CP2 平台层**不反向依赖**业务层:`platform/**` 不许 `use crate::modules` -# CP3 业务层**不直接调**平台层的种子:`modules/**` 不许 `platform::seed` -# (接线只在装配根 `bootstrap.rs`) -# CP4 每个业务模块必须声明自己的菜单(`*_MENU: MenuSpec`)⇒ 且被 `modules/mod.rs` -# 的 `ALL_MENUS` 收编(漏一处 ⇒ 菜单不显示 / admin 少一条授权) -# ⇒ 且声明的菜单 id 与**契约** `[MENU]` 里该模块那一行一致 -# CP5 `platform::seed::ensure_base` 的调用点**只有** `bootstrap.rs` -# (应用与测试都走装配根 ⇒ 测到的库 == 上线的库) -# CP6 平台层自带菜单**恰好 N 条**(N 由**契约**推出来:契约菜单数 − 业务模块数) -# ⇒ 且平台层那几条的 id **逐条**等于契约里「非业务」的那些菜单 -# -# 🔴 **期望值来自 `docs/contract.md` 附录 A**(机器可读)⇒ 加业务模块时 -# 「契约加一行」自动把 CP4/CP6 的期望值也带上了(脚本不硬编码 5 / 3 / 8)。 - -set -u - -ROOT="$(cd "$(dirname "$0")/.." && pwd)" - -BACKEND="$ROOT/src/backend" -SRC="$BACKEND/src" -PLATFORM="$SRC/platform" -MODULES="$SRC/modules" -MODULES_MOD="$MODULES/mod.rs" -BOOTSTRAP="$SRC/bootstrap.rs" -SCAN="$ROOT/scripts/check-boundary-scan.py" - -usage() { - echo "用法: bash scripts/check-boundary.sh" - echo " 纯静态检查「平台层 / 业务层」分层红线(CLAUDE.md 红线 12)" - echo "退出码: 0 全过 / 1 有 ❌ 项 / 2 用法错" -} - -if [ "${1:-}" = "-h" ] || [ "${1:-}" = "--help" ]; then - usage - exit 0 -fi -if [ "$#" -ne 0 ]; then - echo "❌ 未知参数: ${1}" - usage - exit 2 -fi - -# ---- 前置:python3 必须在(扫描器靠它)---- -PY_BIN="${PY_BIN-$(command -v python3 2>/dev/null || true)}" -if [ -z "${PY_BIN}" ]; then - echo "❌ 找不到 python3(扫描器需要它)" - exit 2 -fi -if [ ! -f "${SCAN}" ]; then - echo "❌ 缺扫描器: ${SCAN}" - exit 2 -fi - -# ---- 契约期望值(唯一真源:docs/contract.md 附录 A)---- -CE_PY="$ROOT/scripts/contract_expect.py" -if [ ! -f "${CE_PY}" ]; then - echo "❌ 缺契约期望值读取器: ${CE_PY}" - exit 2 -fi -ce() { "${PY_BIN}" "${CE_PY}" "$@"; } -CE_MENU_ROWS="$(ce rows MENU 2>/dev/null)" || CE_MENU_ROWS="" -CE_MOD_ROWS="$(ce rows MODULE 2>/dev/null)" || CE_MOD_ROWS="" -CE_RULER_ROWS="$(ce rows RULER 2>/dev/null)" || CE_RULER_ROWS="" -if [ -z "${CE_MENU_ROWS}" ] || [ -z "${CE_MOD_ROWS}" ] || [ -z "${CE_RULER_ROWS}" ]; then - echo "❌ 读契约期望值失败(docs/contract.md 附录 A 是不是被改坏了?)" - exit 2 -fi -CE_MENU_COUNT="$(printf '%s\n' "${CE_MENU_ROWS}" | awk -F'\t' 'NR>1 { n++ } END { print n + 0 }')" -CE_MOD_COUNT="$(printf '%s\n' "${CE_MOD_ROWS}" | awk -F'\t' 'NR>1 { n++ } END { print n + 0 }')" -# 平台层该有几条菜单 = 契约菜单总数 − 业务模块数(每个业务模块恰好一条业务菜单) -CE_EXP_PLATFORM_MENUS=$((CE_MENU_COUNT - CE_MOD_COUNT)) -# 契约里「属于业务模块的那些菜单 id」(= [MODULE] 的 menuId 列) -CE_BUSINESS_MENU_IDS="$(printf '%s\n' "${CE_MOD_ROWS}" | awk -F'\t' 'NR>1 { print $6 }' | tr '\n' ' ')" - -PASS=0; FAIL=0 -ok() { echo " ✅ $1"; PASS=$((PASS+1)); } -no() { echo " ❌ $1"; FAIL=$((FAIL+1)); } -hdr() { echo; echo "── $1 ──"; } - -# ---- CP1' 反自证:扫描器自己必须能抓到泄漏 ---- -hdr "[CP1'] 扫描器反自证(--self-test 必须过)" -SELFTEST_OUT="$("${PY_BIN}" "${SCAN}" --self-test 2>&1)" -if [ "$?" -eq 0 ]; then - ok "扫描器自证通过:${SELFTEST_OUT}" -else - no "扫描器自证失败:${SELFTEST_OUT}" -fi - -# ---- CP1 平台层零业务标识符 ---- -hdr "[CP1] 平台层零业务标识符(扫字符串字面量;禁止清单从业务层派生)" -SCAN_OUT="$("${PY_BIN}" "${SCAN}" "${MODULES}" "${PLATFORM}" "${SRC}/routes.rs" "${SRC}/main.rs" "${BOOTSTRAP}" 2>&1)" -if [ "$?" -eq 0 ]; then - ok "平台层没有业务标识符($(printf '%s\n' "${SCAN_OUT}" | tail -1))" -else - no "平台层出现业务标识符:" - printf '%s\n' "${SCAN_OUT}" | sed 's/^/ /' -fi - -# ---- CP2 平台层不反向依赖业务层 ---- -hdr "[CP2] 平台层不反向依赖业务层(platform/** 不许 use crate::modules)" -CP2_HITS="$(grep -rn "use crate::modules" "${PLATFORM}" 2>/dev/null)" -if [ -z "${CP2_HITS}" ]; then - ok "platform/** 没有 use crate::modules" -else - no "platform/** 引用了业务层:" - printf '%s\n' "${CP2_HITS}" | sed 's/^/ /' -fi - -# ---- CP3 业务层不直接调平台层的种子 ---- -hdr "[CP3] 业务层不直接调平台层种子(modules/** 不许 platform::seed)" -CP3_HITS="$(grep -rn "platform::seed" "${MODULES}" 2>/dev/null)" -if [ -z "${CP3_HITS}" ]; then - ok "modules/** 没有 platform::seed(接线只在装配根)" -else - no "modules/** 调了平台层的种子:" - printf '%s\n' "${CP3_HITS}" | sed 's/^/ /' -fi - -# ---- CP4 每个业务模块声明自己的菜单 + 被 ALL_MENUS 收编 ---- -hdr "[CP4] 每个业务模块声明自己的菜单(*_MENU: MenuSpec)并被 ALL_MENUS 收编" -MENU_FILES=0 -MENU_MISSING="" -MENU_UNREGISTERED="" -MENU_MISMATCH="" -for f in "${MODULES}"/*.rs; do - base="$(basename "$f")" - [ "${base}" = "mod.rs" ] && continue - MENU_FILES=$((MENU_FILES+1)) - consts="$(grep -o "^pub const [A-Z_]*_MENU: MenuSpec" "$f" 2>/dev/null | sed 's/^pub const //; s/: MenuSpec$//')" - if [ -z "${consts}" ]; then - MENU_MISSING="${MENU_MISSING} ${base}" - continue - fi - for c in ${consts}; do - if ! grep -q "${c}," "${MODULES_MOD}" 2>/dev/null; then - MENU_UNREGISTERED="${MENU_UNREGISTERED} ${c}(${base})" - fi - done - # 🔴 声明的菜单 id 必须与**契约** `[MODULE].menuId` 一致(该模块的菜单是哪一条, - # 是契约说了算,不是代码自己说了算)。 - C_MENU_ID="$(printf '%s\n' "${CE_MOD_ROWS}" | awk -F'\t' -v f="${base}" 'NR>1 && $8==f { print $6; exit }')" - D_MENU_ID="$(awk '/^[ \t]*id:[ \t]*"/ { s = $0; sub(/^[ \t]*id:[ \t]*"/, "", s); sub(/".*/, "", s); print s; exit }' "$f")" - if [ -z "${C_MENU_ID}" ]; then - MENU_MISMATCH="${MENU_MISMATCH} ${base}(契约 [MODULE] 里没有它)" - elif [ "${C_MENU_ID}" != "${D_MENU_ID}" ]; then - MENU_MISMATCH="${MENU_MISMATCH} ${base}(声明=${D_MENU_ID:-无} 契约=${C_MENU_ID})" - fi -done -if [ -n "${MENU_MISSING}" ]; then - no "这些业务模块没声明菜单(缺 *_MENU: MenuSpec):${MENU_MISSING}" -else - ok "${MENU_FILES} 个业务模块都声明了 *_MENU: MenuSpec" -fi -if [ -n "${MENU_UNREGISTERED}" ]; then - no "这些菜单没被 modules/mod.rs 的 ALL_MENUS 收编(菜单不会被种、admin 少一条授权):${MENU_UNREGISTERED}" -else - ok "全部业务菜单都被 ALL_MENUS 收编" -fi -if [ -n "${MENU_MISMATCH}" ]; then - no "这些业务模块声明的菜单 id 与契约 [MODULE] 对不上:${MENU_MISMATCH}" -else - ok "业务模块声明的菜单 id 与契约 [MODULE] 逐条一致" -fi - -# 🔴 **数量对账**:业务模块文件里的 *_MENU 个数 == ALL_MENUS 里的条目数。 -ALL_MENUS_COUNT="$(awk ' - /pub const ALL_MENUS: &\[MenuSpec\] = &\[/ { inb = 1; next } - inb && /^\];/ { inb = 0; next } - inb && /_MENU,/ { n++ } - END { print n + 0 } -' "${MODULES_MOD}")" -DECLARED_COUNT="$(grep -h -c "^pub const [A-Z_]*_MENU: MenuSpec" "${MODULES}"/*.rs 2>/dev/null | awk '{ s += $1 } END { print s + 0 }')" -if [ "${ALL_MENUS_COUNT}" = "${DECLARED_COUNT}" ]; then - ok "ALL_MENUS 条目数 = 各模块声明的 *_MENU 个数(${ALL_MENUS_COUNT})" -else - no "ALL_MENUS 有 ${ALL_MENUS_COUNT} 条,各模块声明了 ${DECLARED_COUNT} 个 *_MENU ⇒ 对不上" -fi - -# ---- CP5 ensure_base 的调用点只有装配根 ---- -hdr "[CP5] platform::seed::ensure_base 的调用点只有装配根 bootstrap.rs" -CP5_HITS="$(grep -rn "seed::ensure_base" "${SRC}" 2>/dev/null | grep -v "^${BOOTSTRAP}:" )" -if [ -z "${CP5_HITS}" ]; then - ok "只有 bootstrap.rs 调 seed::ensure_base(应用与测试走同一条路)" -else - no "这些地方绕过装配根调了 seed::ensure_base:" - printf '%s\n' "${CP5_HITS}" | sed 's/^/ /' -fi - -# ---- CP6 平台层自带菜单:条数与 id 都由**契约**推出来 ---- -hdr "[CP6] 平台层自带菜单(条数与 id 都由契约 [MENU] 推出来;业务菜单不许混进 platform/seed.rs)" -PLATFORM_MENU_COUNT="$(awk ' - /const BUILTIN_MENUS: \[MenuSpec; / { inb = 1; next } - inb && /^\];/ { inb = 0; next } - inb && /^[[:space:]]*id: "/ { n++ } - END { print n + 0 } -' "${PLATFORM}/seed.rs")" -if [ "${PLATFORM_MENU_COUNT}" -eq "${CE_EXP_PLATFORM_MENUS}" ]; then - ok "platform/seed.rs 的 BUILTIN_MENUS 恰好 ${CE_EXP_PLATFORM_MENUS} 条系统菜单(契约菜单 ${CE_MENU_COUNT} 条 − 业务模块 ${CE_MOD_COUNT} 个)" -else - no "platform/seed.rs 的 BUILTIN_MENUS 有 ${PLATFORM_MENU_COUNT} 条(契约推出应为 ${CE_EXP_PLATFORM_MENUS} 条 = 契约菜单 ${CE_MENU_COUNT} − 业务模块 ${CE_MOD_COUNT})" -fi -# 平台层那几条的 id,必须**逐条**等于契约 [MENU] 里「不属于任何业务模块」的那些 id -PLATFORM_MENU_IDS="$(awk ' - /const BUILTIN_MENUS: \[MenuSpec; / { inb = 1; next } - inb && /^\];/ { inb = 0; next } - inb && /^[[:space:]]*id: "/ { s = $0; sub(/^[ \t]*id: "/, "", s); sub(/".*/, "", s); print s } -' "${PLATFORM}/seed.rs" | sort | tr '\n' ' ')" -CE_PLATFORM_MENU_IDS="$(printf '%s\n' "${CE_MENU_ROWS}" | awk -F'\t' -v biz="${CE_BUSINESS_MENU_IDS}" ' - NR > 1 { - skip = 0 - n = split(biz, ids, " ") - for (i = 1; i <= n; i++) if (ids[i] != "" && ids[i] == $1) skip = 1 - if (!skip) print $1 - } -' | sort | tr '\n' ' ')" -if [ "${PLATFORM_MENU_IDS}" = "${CE_PLATFORM_MENU_IDS}" ]; then - ok "平台层菜单 id 与契约逐条一致:${PLATFORM_MENU_IDS}" -else - no "平台层菜单 id 与契约不一致:平台=${PLATFORM_MENU_IDS:-无} 契约=${CE_PLATFORM_MENU_IDS:-无}" -fi - -# -------- 尺子自证:跑出来的条数必须等于契约里登记的条数 -------- -# -# 🔴 尺子自己知道它断言了几条(PASS+FAIL)。哪天有人删掉几条断言、或者某个分支提前 -# return 了,尺子照样「全绿」—— 变弱的尺子比没有尺子更危险 ⇒ 条数由**契约**钉死。 -CE_EXP_ASSERTIONS="$(printf '%s\n' "${CE_RULER_ROWS}" | awk -F'\t' '$1=="check-boundary.sh" { print $2; exit }')" -hdr "[自证] 尺子条数与契约登记一致" -if [ -n "${CE_EXP_ASSERTIONS}" ]; then - CE_ACT_ASSERTIONS=$((PASS + FAIL)) - if [ "${CE_ACT_ASSERTIONS}" -eq "${CE_EXP_ASSERTIONS}" ]; then - # 自证**不计入** PASS/FAIL(它是元断言,不是业务断言) - echo " ✅ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言 = 契约登记的 ${CE_EXP_ASSERTIONS} 条" - else - echo " ❌ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言,契约登记 ${CE_EXP_ASSERTIONS} 条 ⇒ 尺子被改弱了(少了/多了断言)" - FAIL=$((FAIL + 1)) - fi -fi - -# -------- 总结 -------- -echo -echo "── 总结 ──" -echo "PASS=$PASS FAIL=$FAIL" -if [ "$FAIL" -eq 0 ]; then - echo "全 ✅ 分层红线没被打破" -else - echo "有 ❌,请按上面修复" -fi - -exit $([ "$FAIL" -eq 0 ] && echo 0 || echo 1) diff --git a/scripts/check-citations-scan.py b/scripts/check-citations-scan.py deleted file mode 100644 index 5125ee8..0000000 --- a/scripts/check-citations-scan.py +++ /dev/null @@ -1,570 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -"""check-citations-scan —— 文档引文(`路径:行号`)校验扫描器。 - -🔴 为什么存在: - 本仓的文档(`SKILL.md` / `MIGRATION.md` / `JNPF_SOURCE_AUDIT.md` / `PERMISSION.md` …) - 大量引用源码位置,语法有三种: - `文件.ext:行号` 单行 - `文件.ext:起-止` 区间 - `文件.ext:行/行/行` 多个散行(斜杠 = 「这几行分别」) - `文件.ext:行+` 该行及其后 - 这些行号是**会漂移**的:源码改一行 ⇒ 上游行号整体位移 ⇒ 文档里的引用 - **静默指向别的行**——不报错,只是悄悄说错话。⇒ 必须有把行号核对清楚的尺子。 - -🔴 纯静态:只读文件,不起服务、不连库、不发请求。纯 `python3`(macOS 自带)。 - -用法: - check-citations-scan.py --root <仓根> [--jnpf <官方源码根>] [--react ] - check-citations-scan.py --list # 打印每条引文明细(排查用) - check-citations-scan.py --self-test # 反自证:注入已知坏引用 ⇒ 必须被抓 - -输出协议(制表符分隔,逐行一条): - CHECK\t\t\t<说明> - WARN\t\t<说明> - -退出码:0 = 扫完(看输出里的 DRIFT)/ 2 = 致命错误(参数错等) -""" - -import argparse -import os -import re -import shutil -import sys -import tempfile - -HERE = os.path.dirname(os.path.abspath(__file__)) -ROOT = os.path.dirname(HERE) - -# 外部参照根(可用环境变量 / 命令行覆盖) -DEFAULT_JNPF = os.path.expanduser("~/Desktop/workspace/jnpf") -DEFAULT_REACT = os.path.expanduser("~/Desktop/workspace/skills/ssw-jnpf-lite-react") -DEFAULT_DDL = os.path.expanduser( - "~/Desktop/workspace/jnpf/jnpf-database/PostgreSQL/JNPF-PostgreSQL.sql" -) -# 依赖源码根(cargo registry)—— 文档里会引「某个 crate 的某一版源码的某一行」 -DEFAULT_CARGO = os.path.expanduser("~/.cache/cargo/registry/src") -CARGO_FALLBACK = os.path.expanduser("~/.cargo/registry/src") - -# 遍历时跳过的目录(构建产物 / 依赖树 / 运行期数据) -SKIP_DIRS = { - ".git", ".idea", ".vscode", "node_modules", "target", "dist", "build", - ".next", ".nuxt", "data", "__pycache__", ".venv", "venv", "vendor", - ".workbuddy", ".superpowers", "coverage", ".pytest_cache", ".mypy_cache", -} - -# 文档语料:仓根 *.md + docs/** + references/**(不含 template-boot-jnpf —— 那是另一份骨架) -DOC_GLOBS = ( - ("", "*.md"), - ("docs", "**/*.md"), - ("references", "*.md"), -) - -# 承认的文件后缀(决定什么算「一条引文」) -EXTS = ( - "rs|ts|tsx|jsx|js|vue|sql|sh|py|java|kt|xml|yml|yaml|json|md|html|" - "css|scss|toml|properties|gradle|c|h|go|txt|conf|ini" -) - -# 引文本体:路径 + 行号部分 -CITE_RE = re.compile( - r"(?P(?:[A-Za-z0-9_.\-]+/)*[A-Za-z0-9_.\-]*\.(?:" + EXTS + r"))" - r":(?P\d+(?:(?:\s*[/\-]\s*)\d+)*\+?)" -) - -# 「被提及的文件名」(不带行号)—— 用于给孤儿行号继承上文文件名 -# 🔴 允许 `~/` 前缀(文档里常见 `~/Desktop/workspace/jnpf/…` 这种绝对坐标) -FILE_RE = re.compile( - r"(?P~?/?(?:[A-Za-z0-9_.\-]+/)*[A-Za-z0-9_.\-]*\.(?:" + EXTS + r"))" -) - -# 孤儿行号(`:4503` 这种没有路径的续行引用)—— 只报不判失败 -ORPHAN_RE = re.compile(r"(? 0 and text[m.start() - 1] in "\"'": - continue - # 🔴 **端口号不是引文**:本仓的端口一律写成反引号包裹的 `` `:30010` ``。 - # 判据 = 反引号包裹 **且** 数值 ≥ 1024(真引文的行号在同一写法下都 < 1024, - # 而 DDL 那种大行号(812/2209/…)**不**用反引号包裹)。 - # 🔴 **端口号不是引文**:本仓的端口写成 `` `:30010` `` 或行内的 `后端 :30010`。 - # 判据 = 数字**后面还跟着别的内容**(行内写法)⇒ 端口 / 版本号 / 别的数值; - # 数字**后面是行尾或表格竖线**(列写法)⇒ 才是行号引用。 - # (两种写法的区别是结构性的,不是猜的。) - tail = text[m.end():] - stripped = tail.lstrip(" \t`") - if stripped and not stripped.startswith("|"): - continue - # 表格单元格里的 `` `:30000` `` 同样是端口(数值 ≥ 1024 且被反引号包着) - num = int(m.group(1)) - backticked = (m.start() > 0 and text[m.start() - 1] == "`" - and m.end() < len(text) and text[m.end()] == "`") - if backticked and num >= 1024: - continue - inherited = None - for pos, name in reversed(mentions): - if pos < m.start(): - inherited = name - break - orphans.append({ - "doc": path, - "doc_line": text.count("\n", 0, m.start()) + 1, - "line": int(m.group(1)), - "inherited": inherited, - }) - return cites, orphans, mentions_by_doc - - -def resolve(cite_path, roots, indexes): - """把引文里的路径解析成候选文件列表 [(root名, 绝对路径), …]。 - - 三级解析(先精确后模糊): - ① 精确:<根>/<路径> 存在 - ② 后缀:某根下存在相对路径以 `/<路径>` 结尾(覆盖 `db/schema.sql` → `src/backend/db/schema.sql`) - ③ 基名:路径里没有 `/` 时,按文件名在全仓找(官方源码文档里大量 `XxxController.java:27` 这类写法) - 🔴 `~/` 开头的按**绝对路径**处理(文档里直接写官方源码坐标)。 - """ - cands = [] - expanded = os.path.expanduser(cite_path) - if expanded.startswith("/"): - if os.path.isfile(expanded): - cands.append(("abs", expanded)) - return cands, "abs" - - for name, base in roots.items(): - p = os.path.join(base, cite_path) - if os.path.isfile(p): - cands.append((name, p)) - if cands: - return cands, "exact" - - suffix = "/" + cite_path - for name, base in roots.items(): - for rel, ap in indexes.get(name, {}).items(): - if rel.endswith(suffix): - cands.append((name, ap)) - if cands: - return cands, "suffix" - - if "/" not in cite_path: - for name, base in roots.items(): - for rel, ap in indexes.get(name, {}).items(): - if os.path.basename(rel) == cite_path: - cands.append((name, ap)) - if cands: - return cands, "basename" - return [], "none" - - -def judge(citation, roots, indexes): - """判定一条引文。返回 (状态, 解析结果, 说明)。 - - 状态:OK / RANGE_BAD(文件在但行号越界)/ UNRESOLVED(文件找不到) - """ - cands, tier = resolve(citation["path"], roots, indexes) - if not cands: - return "UNRESOLVED", [], "找不到文件" - fits = [] - for name, ap in cands: - lc = line_count(ap) - if all(start <= lc and (end is None or end <= lc) for start, end in citation["spans"]): - fits.append((name, ap)) - if fits: - return "OK", fits, tier - detail = "、".join( - "%s(%d 行)" % (os.path.relpath(ap, roots[name]), line_count(ap)) - for name, ap in cands[:3] - ) - return "RANGE_BAD", cands, detail - - -# ---------------------------------------------------------------- 检查项 - - -def check_citations(cites, roots, indexes, missing_roots): - """CIT1 可解析 / CIT2 行号有效。返回 (c1_status, c1_detail, c2_status, c2_detail, bad列表)。""" - unresolved = [] - bad_range = [] - for c in cites: - status, cands, detail = judge(c, roots, indexes) - c["status"] = status - c["detail"] = detail - if status == "UNRESOLVED": - unresolved.append(c) - elif status == "RANGE_BAD": - bad_range.append(c) - - # CIT1 —— 可解析 - if not unresolved: - c1_status, c1_detail = "OK", "%d 条引文全部定位到真实文件" % len(cites) - elif missing_roots: - c1_status = "SKIP" - c1_detail = "%d 条引文定位不到(外部参照根缺失:%s ⇒ 跳过,不判失败)" % ( - len(unresolved), "、".join(missing_roots)) - else: - c1_status = "DRIFT" - c1_detail = "%d 条引文定位不到文件:%s" % ( - len(unresolved), - ";".join("%s:%d → %s" % (os.path.basename(c["doc"]), c["doc_line"], c["path"]) - for c in unresolved[:6])) - - # CIT2 —— 行号有效 - if not bad_range: - c2_status, c2_detail = "OK", "%d 条引文的行号全部落在文件行数内" % len(cites) - else: - c2_status = "DRIFT" - c2_detail = "%d 条引文行号越界:%s" % ( - len(bad_range), - ";".join("%s:%d → %s(文件最多 %s 行)" % ( - os.path.basename(c["doc"]), c["doc_line"], c["path"], c["detail"]) - for c in bad_range[:6])) - return c1_status, c1_detail, c2_status, c2_detail, unresolved + bad_range - - -# 孤儿行号的「上文窗口」:文件通常在同一个小节 / 同一张表里被点名 -ORPHAN_WINDOW = 40 - - -def check_orphans(orphans, roots, indexes, mentions_by_doc): - """核对「孤儿行号」(`:NNN`)。 - - 🔴 **为什么不能简单「继承上文最近的文件名」**:同一张表里**相邻两行可能指的是不同文件** - (官方文档的表常在「官方出处」列里写 `前端 xxx.ts:14` 与 `XxxController.java:107-110` 混排) - ⇒ 机械继承会**大量误报**。 - - ⇒ 折中口径:取**上文 40 行内被点名过的所有文件**,只要**其中任意一个**的行数 - 覆盖得住这个行号 ⇒ 视为「对得上」(弱判据、低误报)。 - 一个都对不上 ⇒ 报「疑似漂移」(**只报不判失败**)。 - """ - checked = 0 - unresolved = 0 - suspects = [] - for o in orphans: - near = mentions_by_doc.get(o["doc"], []) - cands = [] - for (line, name) in near: - if not (o["doc_line"] - ORPHAN_WINDOW <= line <= o["doc_line"]): - continue - got, _ = resolve(name, roots, indexes) - cands.extend(got) - if not cands: - unresolved += 1 - continue - checked += 1 - if not any(o["line"] <= line_count(ap) for _, ap in cands): - suspects.append("%s:%d → 引用了第 %d 行,但上文 40 行内点名的文件最多只有 %d 行" % ( - os.path.basename(o["doc"]), o["doc_line"], o["line"], - max(line_count(ap) for _, ap in cands))) - return checked, unresolved, suspects - - -def check_ddl_table(root, ddl_path): - """CIT3 —— 文档里的 DDL 行号表 ↔ 官方 DDL 真实行。 - - 文档写「`base_authorize` | 812」⇒ 官方 DDL 第 812 行必须真的有 - `CREATE TABLE base_authorize` ⇒ 行号漂移(DDL 增删表)当场被抓。 - """ - claude = os.path.join(root, "CLAUDE.md") - if not os.path.isfile(claude): - return "SKIP", "仓根没有 CLAUDE.md" - if not os.path.isfile(ddl_path): - return "SKIP", "官方 DDL 不存在:%s" % ddl_path - with open(claude, "r", encoding="utf-8", errors="replace") as fh: - text = fh.read() - rows = DDL_ROW_RE.findall(text) - if not rows: - return "SKIP", "CLAUDE.md 里没有 DDL 行号表" - try: - with open(ddl_path, "r", encoding="utf-8", errors="replace") as fh: - ddl_lines = fh.readlines() - except OSError as exc: - return "SKIP", "读官方 DDL 失败:%s" % exc - - bad = [] - for name, num in rows: - n = int(num) - if n < 1 or n > len(ddl_lines): - bad.append("%s 标 %d 行(DDL 共 %d 行)" % (name, n, len(ddl_lines))) - continue - line = ddl_lines[n - 1] - if not re.search(DDL_CREATE_RE.format(name=re.escape(name)), line, re.I): - bad.append("%s 标 %d 行,但该行是「%s」" % (name, n, line.strip()[:60])) - if bad: - return "DRIFT", "DDL 行号漂移 %d 条:%s" % (len(bad), ";".join(bad)) - return "OK", "%d 条 DDL 行号与官方 DDL 逐行对上" % len(rows) - - -# ---------------------------------------------------------------- 反自证 - - -def self_test(): - """注入已知坏引文 ⇒ 必须被抓到。永远返回「干净」的尺子 = 没有尺子。""" - failures = [] - - tmpdir = tempfile.mkdtemp(prefix="cite-selftest-") - try: - # 造一份「干净」的文档 + 一个假源码文件 - src_dir = os.path.join(tmpdir, "src") - os.makedirs(src_dir) - code = os.path.join(src_dir, "demo.rs") - with open(code, "w", encoding="utf-8") as fh: - fh.write("\n".join("line%d" % i for i in range(1, 21)) + "\n") # 20 行 - doc = os.path.join(tmpdir, "doc.md") - with open(doc, "w", encoding="utf-8") as fh: - fh.write("见 `src/demo.rs:5` 与 `src/demo.rs:12-18`。\n") - - roots = {"tmp": tmpdir} - indexes = {"tmp": build_index(tmpdir)} - cites, _, _ = extract_citations([doc]) - c1, _, c2, _, bad = check_citations(cites, roots, indexes, []) - if c1 != "OK" or c2 != "OK" or bad: - failures.append("干净引文被误判(c1=%s c2=%s bad=%d)" % (c1, c2, len(bad))) - - # 注入 1:行号越界 - with open(doc, "w", encoding="utf-8") as fh: - fh.write("见 `src/demo.rs:999`。\n") - cites, _, _ = extract_citations([doc]) - _, _, c2, _, bad = check_citations(cites, roots, indexes, []) - if c2 != "DRIFT": - failures.append("行号越界没被抓到(c2=%s)" % c2) - - # 注入 2:文件不存在 - with open(doc, "w", encoding="utf-8") as fh: - fh.write("见 `src/nope.rs:3`。\n") - cites, _, _ = extract_citations([doc]) - c1, _, _, _, bad = check_citations(cites, roots, indexes, []) - if c1 != "DRIFT": - failures.append("文件不存在没被抓到(c1=%s)" % c1) - - # 注入 3:DDL 行号写错 - ddl = os.path.join(tmpdir, "ddl.sql") - with open(ddl, "w", encoding="utf-8") as fh: - fh.write("CREATE TABLE base_alpha (\n a int\n);\n") - claude = os.path.join(tmpdir, "CLAUDE.md") - with open(claude, "w", encoding="utf-8") as fh: - fh.write("| `base_alpha` | 1 | x |\n") - st, _ = check_ddl_table(tmpdir, ddl) - if st != "OK": - failures.append("正确 DDL 行号被误判(%s)" % st) - with open(claude, "w", encoding="utf-8") as fh: - fh.write("| `base_alpha` | 2 | x |\n") - st, _ = check_ddl_table(tmpdir, ddl) - if st != "DRIFT": - failures.append("DDL 行号错位没被抓到(%s)" % st) - finally: - shutil.rmtree(tmpdir, ignore_errors=True) - - if failures: - for f in failures: - print("SELFTEST-FAIL\t%s" % f) - return 1 - print("反自证通过:行号越界 / 文件缺失 / DDL 行号错位 三类坏引用都被抓到,干净引文不误报") - return 0 - - -# ---------------------------------------------------------------- 主流程 - - -def main(argv): - ap = argparse.ArgumentParser(description="文档引文(路径:行号)校验扫描器") - ap.add_argument("--root", default=ROOT, help="仓根(默认:本脚本所在仓)") - ap.add_argument("--jnpf", default=os.environ.get("JNPF_SRC_ROOT", DEFAULT_JNPF), - help="官方 JNPF 源码根") - ap.add_argument("--react", default=os.environ.get("REACT_SKILL_ROOT", DEFAULT_REACT), - help="react 姊妹技能根") - ap.add_argument("--ddl", default=os.environ.get("JNPF_DDL", DEFAULT_DDL), - help="官方 DDL 文件") - ap.add_argument("--cargo", default=os.environ.get("CARGO_SRC_ROOT", DEFAULT_CARGO), - help="cargo registry 的 src 目录(引文指到依赖源码时用)") - ap.add_argument("--list", action="store_true", help="打印每条引文明细") - ap.add_argument("--self-test", action="store_true", help="反自证模式") - args = ap.parse_args(argv) - - if args.self_test: - return self_test() - - root = os.path.abspath(args.root) - if not os.path.isdir(root): - print("❌ 仓根不存在:%s" % root) - return 2 - - roots = { - "repo": root, - "jnpf": os.path.abspath(os.path.expanduser(args.jnpf)), - "react": os.path.abspath(os.path.expanduser(args.react)), - } - # 依赖源码根(pglite-rs 的各版本)—— 文档里会引「某依赖的某一行」 - cargo_base = os.path.abspath(os.path.expanduser(args.cargo)) - if not os.path.isdir(cargo_base) and os.path.isdir(CARGO_FALLBACK): - cargo_base = CARGO_FALLBACK - for i, crate_root in enumerate(cargo_crate_roots(cargo_base)): - roots["cargo%d" % i] = crate_root - - missing_roots = [n for n, p in roots.items() if not os.path.isdir(p)] - indexes = {n: build_index(p) for n, p in roots.items() if os.path.isdir(p)} - - docs = collect_docs(root) - cites, orphans, mentions_by_doc = extract_citations(docs) - - c1, c1d, c2, c2d, bad = check_citations(cites, roots, indexes, missing_roots) - emit_check("CIT1", c1, c1d) - emit_check("CIT2", c2, c2d) - c3, c3d = check_ddl_table(root, os.path.abspath(os.path.expanduser(args.ddl))) - emit_check("CIT3", c3, c3d) - - o_checked, o_unresolved, o_suspects = check_orphans(orphans, roots, indexes, mentions_by_doc) - if orphans: - emit_warn("CIT-W1", "%d 处「无路径的续行行号」(`:NNN`,本仓的表格约定)—— " - "按上文最近的文件名继承核对:%d 处对得上,%d 处无法定位" % ( - len(orphans), o_checked, o_unresolved)) - for s in o_suspects[:8]: - emit_warn("CIT-W1", "疑似漂移:%s" % s) - if missing_roots: - emit_warn("CIT-W2", "外部参照根缺失:%s ⇒ 指向它们的引文按「跳过」处理" - % "、".join("%s=%s" % (n, roots[n]) for n in missing_roots)) - - if args.list: - print("---- 引文明细 ----") - for c in cites: - print("%s:%d\t%s:%s\t%s\t%s" % ( - os.path.relpath(c["doc"], root), c["doc_line"], c["path"], c["body"], - c.get("status", "?"), c.get("detail", ""))) - return 0 - - -if __name__ == "__main__": - sys.exit(main(sys.argv[1:])) diff --git a/scripts/check-citations.sh b/scripts/check-citations.sh deleted file mode 100644 index a22d798..0000000 --- a/scripts/check-citations.sh +++ /dev/null @@ -1,150 +0,0 @@ -#!/usr/bin/env bash -# ssw-jnpf-lite-rust 引文校验尺子 —— 文档里的「路径:行号」是否还指得到真东西 -# -# 目的:本仓的文档(SKILL / README / MIGRATION / JNPF_SOURCE_AUDIT / PERMISSION …) -# 大量引用源码位置 `文件.ext:行号`。这些行号**会漂移**:源码改一行 ⇒ -# 上游行号整体位移 ⇒ 文档里的引用**静默指向别的行**——不报错,只是悄悄说错话。 -# 本尺子把每条引文**解析到真实文件**并核对行号区间;顺带核对 -# 「文档里的 DDL 行号表 ↔ 官方 DDL 真实行」。 -# -# 🔴 **纯静态**:不启动后端、不发请求、不连库。只需要 `python3`(macOS 自带)。 -# -# 用法: -# bash scripts/check-citations.sh # 无参 ⇒ 全查 -# bash scripts/check-citations.sh --list # 顺带打印每条引文明细 -# bash scripts/check-citations.sh --help -# -# 退出码:0 全过 / 1 有 ❌ 项 / 2 用法错或前置错误 -# -# ── 判据(CIT1–CIT3)── -# CIT1 引文**可解析**:每条 `路径:行号` 都能定位到真实文件 -# CIT2 引文**行号有效**:行号区间落在该文件的行数范围内 -# CIT3 **DDL 行号表**对账:文档写的建表行号 ↔ 官方 DDL 那一行真的有 `CREATE TABLE` -# CIT1' **反自证**:注入已知坏引用 ⇒ 必须被抓到(永远返回「干净」的尺子 = 没有尺子) -# -# 🔴 **期望值来自 `docs/contract.md` 附录 A 的 `[RULER]`**(条数由契约钉死)。 - -set -u - -ROOT="$(cd "$(dirname "$0")/.." && pwd)" -SCRIPTS="$ROOT/scripts" -SCAN="$SCRIPTS/check-citations-scan.py" -CE_PY="$SCRIPTS/contract_expect.py" -CONTRACT="$ROOT/docs/contract.md" - -usage() { - echo "用法: bash scripts/check-citations.sh [--list]" - echo " 静态校验文档里的「路径:行号」引文是否还指得到真东西" - echo "退出码: 0 全过 / 1 有 ❌ / 2 用法错或前置错误" -} - -LIST="" -while [ "$#" -gt 0 ]; do - case "$1" in - -h|--help) usage; exit 0 ;; - --list) LIST="--list"; shift ;; - *) echo "❌ 未知参数: $1"; usage; exit 2 ;; - esac -done - -# ---- 前置:python3 / 扫描器 / 契约文件 ---- -PY_BIN="${PY_BIN-$(command -v python3 2>/dev/null || true)}" -if [ -z "${PY_BIN}" ]; then - echo "❌ 找不到 python3(扫描器需要它)" - exit 2 -fi -if [ ! -f "${SCAN}" ]; then - echo "❌ 缺扫描器: ${SCAN}" - exit 2 -fi -if [ ! -f "${CE_PY}" ] || [ ! -f "${CONTRACT}" ]; then - echo "❌ 缺契约期望值读取器或契约文件(docs/contract.md 附录 A)" - exit 2 -fi - -# ---- 契约期望值(唯一真源:docs/contract.md 附录 A)---- -CE_RULER_ROWS="$("${PY_BIN}" "${CE_PY}" rows RULER 2>/dev/null)" || CE_RULER_ROWS="" -if [ -z "${CE_RULER_ROWS}" ]; then - echo "❌ 读契约期望值失败(docs/contract.md 附录 A 是不是被改坏了?)" - exit 2 -fi -CE_EXP_ASSERTIONS="$(printf '%s\n' "${CE_RULER_ROWS}" | awk -F'\t' '$1=="check-citations.sh" { print $2; exit }')" - -PASS=0; FAIL=0 -ok() { echo " ✅ $1"; PASS=$((PASS+1)); } -no() { echo " ❌ $1"; FAIL=$((FAIL+1)); } -skip(){ echo " ⏭ $1"; PASS=$((PASS+1)); } # 外部参照根缺失 ⇒ 跳过但仍计入条数 -hdr() { echo; echo "── $1 ──"; } - -# ---- 跑扫描器 ---- -SCAN_OUT="$("${PY_BIN}" "${SCAN}" --root "${ROOT}" ${LIST} 2>&1)" -SCAN_RC=$? -if [ "${SCAN_RC}" -eq 2 ]; then - echo "❌ 扫描器前置失败:" - printf '%s\n' "${SCAN_OUT}" | sed 's/^/ /' - exit 2 -fi - -hdr "[CIT1–CIT3] 文档引文(路径:行号)逐条核对" -DRIFT_LINES="" -while IFS=$'\t' read -r kind f1 f2 f3; do - [ -z "${kind:-}" ] && continue - case "${kind}" in - CHECK) - case "${f2}" in - OK) ok "${f1}:${f3}" ;; - SKIP) skip "${f1}:${f3}" ;; - *) no "${f1}:${f3}" ;; - esac - ;; - WARN) - # WARN 行只有 3 列(kind / id / 说明)⇒ 说明在 f2 - if [ -n "${f3:-}" ]; then - DRIFT_LINES="${DRIFT_LINES}${f1}:${f3}"$'\n' - else - DRIFT_LINES="${DRIFT_LINES}${f1}:${f2}"$'\n' - fi - ;; - esac -done <<< "${SCAN_OUT}" - -if [ -n "${DRIFT_LINES}" ]; then - hdr "提示" - printf '%s' "${DRIFT_LINES}" | sed 's/^/ ⚠️ /' -fi - -# ---- CIT1' 反自证:尺子自己必须能抓到坏引用 ---- -hdr "[CIT1'] 扫描器反自证(--self-test 必须过)" -SELFTEST_OUT="$("${PY_BIN}" "${SCAN}" --self-test 2>&1)" -if [ "$?" -eq 0 ]; then - ok "扫描器自证通过:${SELFTEST_OUT}" -else - no "扫描器自证失败:${SELFTEST_OUT}" -fi - -# -------- 尺子自证:跑出来的条数必须等于契约里登记的条数 -------- -hdr "[自证] 尺子条数与契约登记一致" -if [ -n "${CE_EXP_ASSERTIONS}" ]; then - CE_ACT_ASSERTIONS=$((PASS + FAIL)) - if [ "${CE_ACT_ASSERTIONS}" -eq "${CE_EXP_ASSERTIONS}" ]; then - echo " ✅ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言 = 契约登记的 ${CE_EXP_ASSERTIONS} 条" - else - echo " ❌ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言,契约登记 ${CE_EXP_ASSERTIONS} 条 ⇒ 尺子被改弱了(少了/多了断言)" - FAIL=$((FAIL + 1)) - fi -else - echo " ❌ 契约 [RULER] 里没有登记 check-citations.sh 的期望条数" - FAIL=$((FAIL + 1)) -fi - -# -------- 总结 -------- -echo -echo "── 总结 ──" -echo "PASS=${PASS} FAIL=${FAIL}" -if [ "${FAIL}" -eq 0 ]; then - echo "全 ✅ 文档引文没漂移" -else - echo "有 ❌,请按上面修复(改文档里的行号 ⇒ 跟着源码一起改)" -fi - -exit $([ "${FAIL}" -eq 0 ] && echo 0 || echo 1) diff --git a/scripts/check-contract-scan.py b/scripts/check-contract-scan.py deleted file mode 100644 index 2b70f36..0000000 --- a/scripts/check-contract-scan.py +++ /dev/null @@ -1,751 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -"""check-contract-scan —— **契约 ↔ 代码** 对账扫描器。 - -🔴 为什么存在: - `docs/contract.md` 的端点表原先是**散文表格**(§6.1–§6.5), - 代码里的路由注册是**另一处**(`routes.rs` / `modules/*.rs`)⇒ - 加端点、改路径、改守卫 ⇒ 契约与代码**各改各的** ⇒ 漂移没人发现。 - 本脚本把契约的机器可读区段 `[ENDPOINT]` / `[FACE]` 与**代码里真实注册的路由** - 逐条对账,**双向**都查(契约多 / 代码多 / 方法不符 / 归属层不符 / 守卫不符)。 - -🔴 **只做静态检查**:不启动后端、不发请求。纯 `python3`(macOS 自带)。 - -用法: - check-contract-scan.py --contract <契约文件> --src <后端 src 目录> - check-contract-scan.py --self-test - -输出协议(制表符分隔,逐行一条): - CHECK\t\t\t<说明> - WARN\t\t<说明> # 推不出守卫之类的「非失败但要看见」 - -退出码:0 = 扫完(可能有 DRIFT,看输出)/ 2 = 致命错误(契约读不出来等) -""" - -import io -import os -import re -import shutil -import sys -import tempfile - -HERE = os.path.dirname(os.path.abspath(__file__)) -ROOT = os.path.dirname(HERE) -if HERE not in sys.path: - sys.path.insert(0, HERE) - -import contract_expect # noqa: E402 (同目录) - -# ---------------------------------------------------------------- Rust 源码扫描 - -# 路由注册:`.route("/api/x", get(handler))`(允许跨行) -# 🔴 路径是**字符串字面量** ⇒ 在 masked 里是空白 ⇒ 只在 masked 里定位 `.route(`, -# 再用**同一偏移**去原文取路径与方法。 -ROUTE_CALL_RE = re.compile(r'\.route\(') -# 路由后面的 handler 表达式:`sys::user_list` / `demo_item_list` / `|State(..)| ..`(闭包) -HANDLER_RE = re.compile(r'\s*(?:([A-Za-z_][A-Za-z0-9_]*)::)?([A-Za-z_][A-Za-z0-9_]*)') -# 契约表里 `{param}` ⇒ 代码里的通配 -PARAM_RE = re.compile(r'\{[A-Za-z_][A-Za-z0-9_]*\}') -# 测试用的固定路径前缀(**不在契约端点表里** ⇒ 全部扫描都排除) -TEST_PATH_PREFIX = "/api/__test__/" - - -def mask_rust(text): - """把字符串字面量 / 注释**挖空**(保持长度不变)⇒ 结构扫描不会被注释/字面量骗。 - - 挖空后拿到的偏移量与原文一一对应 ⇒ 需要字面量的值时,用同一偏移去原文里取。 - """ - out = list(text) - n = len(text) - - def blank(a, b): - for k in range(a, b): - if out[k] != "\n": - out[k] = " " - - i = 0 - while i < n: - c = text[i] - if c == "/" and i + 1 < n and text[i + 1] == "/": - j = text.find("\n", i) - j = n if j < 0 else j - blank(i, j) - i = j - continue - if c == "/" and i + 1 < n and text[i + 1] == "*": - depth, j = 1, i + 2 - while j < n and depth: - if text.startswith("/*", j): - depth += 1 - j += 2 - elif text.startswith("*/", j): - depth -= 1 - j += 2 - else: - j += 1 - blank(i, j) - i = j - continue - if c == "r" and i + 1 < n and text[i + 1] in '#"': - m = re.match(r'r(#*)"', text[i:]) - if m: - hashes = m.group(1) - end = text.find('"' + hashes, i + m.end()) - j = n if end < 0 else end + 1 + len(hashes) - blank(i, j) - i = j - continue - if c == '"': - j = i + 1 - while j < n: - if text[j] == "\\": - j += 2 - continue - if text[j] == '"': - j += 1 - break - j += 1 - blank(i, j) - i = j - continue - if c == "'": - m = re.match(r"'(\\.|[^\\'])'", text[i:]) - if m: - blank(i, i + m.end()) - i += m.end() - continue - i += 1 # 生命周期(`'a`)不是字面量 ⇒ 留着 - continue - i += 1 - return "".join(out) - - -def read(path): - with io.open(path, encoding="utf-8") as fh: - return fh.read() - - -def brace_span(masked, start): - """从 `start`(`{` 的位置)开始做括号配对 ⇒ 返回 body 的 (开, 闭) 区间。""" - depth = 0 - i = start - n = len(masked) - while i < n: - c = masked[i] - if c == "{": - depth += 1 - elif c == "}": - depth -= 1 - if depth == 0: - return start, i + 1 - i += 1 - return start, n - - -def find_fn_body(masked, fname): - """找 `fn (` 的函数体区间 ⇒ 返回 (start, end) 或 None。""" - m = re.search(r"\bfn\s+" + re.escape(fname) + r"\s*\(", masked) - if not m: - return None - i = masked.find("{", m.end()) - if i < 0: - return None - return brace_span(masked, i) - - -def scan_routes(path, owner): - """扫一个源文件里的 `.route(...)` ⇒ [{path, method, handler_mod, handler_fn, closure}]。""" - orig = read(path) - masked = mask_rust(orig) - out = [] - for m in ROUTE_CALL_RE.finditer(masked): - p = m.end() - while p < len(orig) and orig[p] in " \t\r\n": - p += 1 - if p >= len(orig) or orig[p] != '"': - continue - q = p + 1 - while q < len(orig) and orig[q] != '"': - if orig[q] == "\\": - q += 1 - q += 1 - if q >= len(orig): - continue - route = orig[p + 1:q] - p = q + 1 - while p < len(orig) and orig[p] in " \t\r\n": - p += 1 - if p < len(orig) and orig[p] == ",": - p += 1 - while p < len(orig) and orig[p] in " \t\r\n": - p += 1 - mm = re.match(r"(get|post|put|delete)\s*\(", orig[p:]) - if not mm: - continue - if masked[p:p + len(mm.group(1))] != mm.group(1): - continue # 方法名其实落在字符串里(误报) - method = mm.group(1).upper() - after = p + mm.end() - if route.startswith(TEST_PATH_PREFIX): - continue # 仅测试构建存在的端点 ⇒ 不在契约端点表里 - rest = orig[after:after + 240] - hm = HANDLER_RE.match(rest) - mod, fn, closure = None, None, True - if hm and hm.group(2): - mod, fn = hm.group(1), hm.group(2) - closure = False - out.append({ - "path": route, - "method": method, - "mod": mod, - "fn": fn, - "closure": closure, - "owner": owner, - "file": path, - }) - return out, orig, masked - - -def resolve_const(orig, masked, name): - """`const NAME: &str = "value";` ⇒ value(取原文里的字面量)。""" - m = re.search(r"\bconst\s+" + re.escape(name) + r"\b[^=]*=\s*\"([^\"]*)\"", orig) - return m.group(1) if m else None - - -def guard_of_platform(plat_files, mod, fn): - """平台层 handler 的守卫 ⇒ 菜单 key / 点权限编码 / 登录 / 无;推不出 ⇒ None。 - - `plat_files` = {"sys": (orig, masked), "jnpf": (orig, masked), ...} - """ - if mod == "auth" and fn == "login_handler": - return "无" - if mod is None: - # routes.rs 里自己定义的 handler(如 `health`)⇒ 没有守卫调用 ⇒ 无 - pair = plat_files.get("__routes__") - if not pair: - return None - orig, masked = pair - span = find_fn_body(masked, fn) - if not span: - return None - body = masked[span[0]:span[1]] - if re.search(r"require_(login|module|login_jnpf)\s*\(", body) or re.search(r"\bguard\s*\(", body): - return None - return "无" - pair = plat_files.get(mod) - if not pair: - return None - orig, masked = pair - span = find_fn_body(masked, fn) - if not span: - return None - body = masked[span[0]:span[1]] - if mod == "sys": - m = re.search(r"require_module\(\s*&state\s*,\s*&headers\s*,\s*([A-Z_][A-Z0-9_]*)\s*\)", body) - if m: - return resolve_const(orig, masked, m.group(1)) - if re.search(r"require_login(_any)?\s*\(", body): - return "登录" - return None - if mod == "jnpf": - 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)) - if re.search(r"require_login_jnpf\s*\(", body): - return "登录" - return None - return None - - -def guard_of_closure(orig, masked, rest): - """闭包 handler(只有 `CurrentUser` 一处)⇒ 看它调了谁。""" - if "auth::current_user" in rest: - return "登录" - return None - - -def guard_of_module(orig, masked): - """业务模块的守卫 ⇒ 它的 `EntitySpec.module_key`(None ⇒ 仅登录)。 - - 🔴 在 **masked** 里定位 `module_key:`(注释里的假 mention 被挖空了), - 再用**同一偏移**去原文取真值(字面量在 masked 里是空格)。 - """ - for m in re.finditer(r"module_key:", masked): - tail = orig[m.end():m.end() + 60] - if re.match(r"\s*None", tail): - return "登录" - mm = re.match(r'\s*Some\(\s*"([^"]*)"\s*\)', tail) - if mm: - return mm.group(1) - return None - - -def parse_str_array(orig, masked, decl_re): - """从 `const X: [&str; N] = [ "a", "b" ];` 里取字符串数组(原文字面量)。""" - m = re.search(decl_re, masked) - if not m: - return None - i = masked.find("[", m.end()) - if i < 0: - return None - j = masked.find("]", i) - if j < 0: - return None - return re.findall(r'"([^"]*)"', orig[i:j]) - - -def path_to_regex(pattern): - """`/a/{id}/b` ⇒ 正则(`{id}` 当通配)⇒ 用来对钉子测试里的具体路径。""" - parts = [] - last = 0 - for m in PARAM_RE.finditer(pattern): - parts.append(re.escape(pattern[last:m.start()])) - parts.append("[^/]+") - last = m.end() - parts.append(re.escape(pattern[last:])) - return re.compile("^" + "".join(parts) + "$") - - -# ---------------------------------------------------------------- 对账 - -class Report(object): - def __init__(self): - self.checks = [] - self.warns = [] - self.infos = [] - - def add(self, cid, ok, detail): - self.checks.append((cid, "OK" if ok else "DRIFT", detail)) - - def warn(self, cid, detail): - self.warns.append((cid, detail)) - - def info(self, cid, detail): - """**不计入 PASS/FAIL** 的进度信息(例:官方端点覆盖 N/M)。""" - self.infos.append((cid, detail)) - - def lines(self): - out = [] - for cid, status, detail in self.checks: - out.append("CHECK\t%s\t%s\t%s" % (cid, status, detail.replace("\t", " "))) - for cid, detail in self.warns: - out.append("WARN\t%s\t%s" % (cid, detail.replace("\t", " "))) - for cid, detail in self.infos: - out.append("INFO\t%s\t%s" % (cid, detail.replace("\t", " "))) - return out - - -def analyze(contract_path, src_dir): - """契约 ↔ 代码 对账主体。返回 (Report, 诊断用数据)。""" - rep = Report() - - sections = contract_expect.load_sections(contract_path) - eps = sections["ENDPOINT"] - faces = sections["FACE"] - - # ---- 代码侧:平台层 + 业务层 ---- - routes_path = os.path.join(src_dir, "routes.rs") - plat, plat_orig, plat_masked = scan_routes(routes_path, "platform") - - plat_dir = os.path.join(src_dir, "platform") - plat_files = {"__routes__": (plat_orig, plat_masked)} - if os.path.isdir(plat_dir): - for name in sorted(os.listdir(plat_dir)): - if name.endswith(".rs"): - p = os.path.join(plat_dir, name) - o = read(p) - plat_files[name[:-3]] = (o, mask_rust(o)) - - mod_dir = os.path.join(src_dir, "modules") - mod_files = [] - if os.path.isdir(mod_dir): - for name in sorted(os.listdir(mod_dir)): - if name.endswith(".rs") and name != "mod.rs": - mod_files.append((name[:-3], os.path.join(mod_dir, name))) - biz = [] - mod_orig = {} - mod_masked = {} - for app, path in mod_files: - rs, orig, masked = scan_routes(path, app) - biz.extend(rs) - mod_orig[app] = orig - mod_masked[app] = masked - code = plat + biz - - code_index = {} - for r in code: - code_index.setdefault((r["method"], r["path"]), r) - - # ---- CC2 端点总数 ---- - ok = len(eps) == len(code) - rep.add("CC2", ok, "契约 %d 条 / 代码 %d 条" % (len(eps), len(code))) - - # ---- CC3 契约 → 代码(存在 + 方法一致)---- - bad3 = [] - for row in eps: - key = (row["method"], row["path"]) - if key in code_index: - continue - other = [k for k in code_index if k[1] == row["path"]] - if other: - bad3.append("%s %s:契约方法 %s,代码是 %s" - % (row["method"], row["path"], row["method"], "/".join(k[0] for k in other))) - else: - bad3.append("%s %s:代码里没有这条路由" % (row["method"], row["path"])) - rep.add("CC3", not bad3, - "契约的 %d 条端点在代码里都能找到(且方法一致)" % len(eps) - if not bad3 else "契约→代码 漂移 %d 条" % len(bad3)) - for d in bad3: - rep.warn("CC3", d) - - # ---- CC4 代码 → 契约(代码多出来的)---- - bad4 = [] - for r in code: - if (r["method"], r["path"]) not in {(x["method"], x["path"]) for x in eps}: - bad4.append("%s %s(%s)" % (r["method"], r["path"], r["owner"])) - rep.add("CC4", not bad4, - "代码里的 %d 条路由都在契约端点表里" % len(code) - if not bad4 else "代码→契约 漂移 %d 条" % len(bad4)) - for d in bad4: - rep.warn("CC4", d) - - # ---- CC5 归属层 ---- - bad5 = [] - for row in eps: - hit = code_index.get((row["method"], row["path"])) - if hit and hit["owner"] != row["owner"]: - bad5.append("%s %s:契约写 %s,代码在 %s" % (row["method"], row["path"], row["owner"], hit["owner"])) - rep.add("CC5", not bad5, - "每条端点的归属层与代码所在文件一致" if not bad5 else "归属层漂移 %d 条" % len(bad5)) - for d in bad5: - rep.warn("CC5", d) - - # ---- CC6 守卫 ---- - bad6 = [] - unknown6 = [] - for row in eps: - hit = code_index.get((row["method"], row["path"])) - if not hit: - continue - derived = None - if hit["owner"] == "platform": - if hit["closure"]: - tail = plat_orig[plat_orig.find(hit["path"]):][:400] - derived = guard_of_closure(plat_orig, plat_masked, tail) - else: - derived = guard_of_platform(plat_files, hit["mod"], hit["fn"]) - else: - derived = guard_of_module(mod_orig[hit["owner"]], mod_masked[hit["owner"]]) - if derived is None: - unknown6.append("%s %s:推不出守卫" % (row["method"], row["path"])) - elif derived != row["guard"]: - bad6.append("%s %s:契约写 %s,代码是 %s" - % (row["method"], row["path"], row["guard"], derived)) - rep.add("CC6", not bad6, - "每条端点的守卫与代码静态推导一致" if not bad6 else "守卫漂移 %d 条" % len(bad6)) - for d in bad6: - rep.warn("CC6", d) - for d in unknown6: - rep.warn("CC6", d + "(**推不出 ≠ 一致**,请人工核对)") - - # ---- CC7 钉子测试清单 ↔ 代码注册路由(双向覆盖)---- - pins = [] - for name in ("REGISTERED", "JNPF_REGISTERED"): - arr = parse_str_array(plat_orig, plat_masked, - r"const\s+" + name + r"\s*:\s*\[&str;\s*\d+\]\s*=") - if arr is not None: - pins.extend(arr) - # 🔴 钉子测试的**字面量清单**(`REGISTERED` / `JNPF_REGISTERED`)只覆盖**平台层**路由; - # 业务路由在钉子测试里是**遍历 `modules::ALL_ROUTES`** ⇒ 归 CC8 对账。 - plat_routes = [r for r in code if r["owner"] == "platform"] - unmatched_pin = [] - for p in pins: - if not any(path_to_regex(r["path"]).match(p) for r in plat_routes): - unmatched_pin.append(p) - unmatched_code = [] - for r in plat_routes: - if not any(path_to_regex(r["path"]).match(p) for p in pins): - unmatched_code.append("%s %s" % (r["method"], r["path"])) - ok7 = not unmatched_pin and not unmatched_code - rep.add("CC7", ok7, - "钉子测试的 %d 条路径与代码注册的 %d 条平台路由双向覆盖" % (len(pins), len(plat_routes)) - if ok7 else "钉子测试清单与代码路由对不上:清单多 %d / 代码多 %d" - % (len(unmatched_pin), len(unmatched_code))) - for d in unmatched_pin: - rep.warn("CC7", "钉子测试里的 %s 在代码里没有对应路由" % d) - for d in unmatched_code: - rep.warn("CC7", "代码里的 %s 没被钉子测试覆盖" % d) - - # ---- CC8 业务路由三处一致(ROUTES 常量 / router() / ALL_ROUTES)---- - bad8 = [] - all_routes = [] - for app, path in mod_files: - orig, masked = mod_orig[app], mod_masked[app] - const = parse_str_array(orig, masked, r"pub\s+const\s+ROUTES\s*:\s*\[&str;\s*\d+\]\s*=") - rs = [r for r in biz if r["owner"] == app] - reg = [r["path"] for r in rs] - if const is None: - bad8.append("%s:没有 ROUTES 常量" % app) - continue - if const != reg: - bad8.append("%s:ROUTES 常量 %s ≠ router() 注册 %s" % (app, const, reg)) - all_routes.extend(const) - # modules/mod.rs 的 ALL_ROUTES(形如 demo::ROUTES[0])⇒ 解析成具体路径 - mod_mod = os.path.join(mod_dir, "mod.rs") - if os.path.isfile(mod_mod): - orig = read(mod_mod) - masked = mask_rust(orig) - m = re.search(r"pub\s+const\s+ALL_ROUTES\s*:\s*&\[&str\]\s*=\s*&\[", masked) - if m: - # 🔴 数组本体是 `&[ ... ]` ⇒ 要**配对**找结尾的 `]`(不能 find 第一个 `]`) - open_at = masked.find("[", m.end() - 1) - depth = 0 - close_at = -1 - for k in range(open_at, len(masked)): - if masked[k] == "[": - depth += 1 - elif masked[k] == "]": - depth -= 1 - if depth == 0: - close_at = k - break - entries = re.findall(r"([a-z_]+)::ROUTES\[(\d+)\]", orig[open_at:close_at]) - resolved = [] - for app, idx in entries: - pair = (mod_orig.get(app, ""), mod_masked.get(app, "")) - c = parse_str_array(pair[0], pair[1], - r"pub\s+const\s+ROUTES\s*:\s*\[&str;\s*\d+\]\s*=") - if c and int(idx) < len(c): - resolved.append(c[int(idx)]) - # 🔴 比**集合**不比你序(`mod_files` 是按文件名排序的,ALL_ROUTES 是按声明序的) - if sorted(resolved) != sorted(all_routes): - bad8.append("modules/mod.rs 的 ALL_ROUTES %s ≠ 各模块 ROUTES 拼接 %s" - % (sorted(resolved), sorted(all_routes))) - else: - bad8.append("modules/mod.rs 里找不到 ALL_ROUTES") - rep.add("CC8", not bad8, - "业务路由三处一致(各模块 ROUTES 常量 / router() 注册 / ALL_ROUTES)" - if not bad8 else "业务路由清单对不上 %d 处" % len(bad8)) - for d in bad8: - rep.warn("CC8", d) - - # ---- CC9 契约面计数自洽 ---- - bad9 = [] - for row in faces: - actual = sum(1 for e in eps if e["face"] == row["face"]) - if str(actual) != row["count"]: - bad9.append("面 %s:契约 [FACE] 登记 %s 条,[ENDPOINT] 里实际 %d 条" - % (row["face"], row["count"], actual)) - total_face = sum(int(r["count"]) for r in faces) - if total_face != len(eps): - bad9.append("[FACE] 合计 %d ≠ [ENDPOINT] 行数 %d" % (total_face, len(eps))) - rep.add("CC9", not bad9, - "各契约面的条数与 [ENDPOINT] 自洽(A/B/AB 合计 %d)" % total_face - if not bad9 else "契约面计数不自洽 %d 处" % len(bad9)) - for d in bad9: - rep.warn("CC9", d) - - # ---- CC10 官方端点台账 ↔ 代码真实路由(双向)---- - # - # 🔴 为什么要它:面 B 的「做了多少」原先只有**尺子的断言数**(18/18)这一个信号, - # 而**官方端点全表**(JNPF_SOURCE_AUDIT.md §4)是**散文表格** ⇒ 官方端点做没做、 - # 做到什么程度,**没有机器可读的账** ⇒ 「覆盖率」只能靠人读散文。 - # 本检查把契约附录 A 的 [OFFICIAL](机器可读)当成**账本**, - # 与代码里**真实注册**的路由双向对账,并打印覆盖 N/M。 - off = sections["OFFICIAL"] - - def norm_path(p): - # `{param}` 归一 ⇒ 官方台账与代码的**参数名不同**也不算漂移 - return re.sub(r"\{[^/{}]*\}", "{}", p) - - code_norm = {} - for r in code: - code_norm.setdefault((r["method"], norm_path(r["path"])), r) - eps_face = {} - for e in eps: - eps_face[(e["method"], norm_path(e["path"]))] = e["face"] - - bad10 = [] - counts = {"implemented": 0, "partial": 0, "absent": 0, "oos": 0} - for row in off: - method, path, status = row["method"], row["path"], row["status"] - if status not in counts: - bad10.append("台账状态非法 %r(%s %s)" % (status, method, path)) - continue - if method == "*" or path.endswith("/**"): - # 「一族端点」的范围声明(如数据权限链接)⇒ 不做存在性对账,只计入 oos - counts["oos"] += 1 - continue - hit = code_norm.get((method, norm_path(path))) - if status in ("implemented", "partial"): - counts[status] += 1 - if hit is None: - bad10.append("台账写 %s(%s %s),代码里**没有**这条路由" % (status, method, path)) - else: - counts[status] += 1 - if hit is not None: - bad10.append("台账写 %s(%s %s),代码里却**注册了**这条路由" % (status, method, path)) - # 反向:代码里**面 B / 共用**的每条路由,都必须在台账里**有账**(防止"实现了但没记账") - off_index = set((r["method"], norm_path(r["path"])) for r in off if r["method"] != "*") - for r in code: - key = (r["method"], norm_path(r["path"])) - if eps_face.get(key) in ("B", "AB") and key not in off_index: - bad10.append("代码注册了面 %s 路由 %s %s,但官方端点台账里**没有这一条**" - % (eps_face.get(key), r["method"], r["path"])) - covered = counts["implemented"] + counts["partial"] - total = covered + counts["absent"] - rep.add("CC10", not bad10, - "官方端点台账与代码真实路由双向对得上(已落地 %d / 在范围 %d)" % (covered, total) - if not bad10 else "官方端点台账漂移 %d 处" % len(bad10)) - for d in bad10: - rep.warn("CC10", d) - rep.info("CC10-COVER", - "官方端点覆盖 %d/%d(implemented %d / partial %d / absent %d;oos %d 单列,不进分母)" - % (covered, total, counts["implemented"], counts["partial"], - counts["absent"], counts["oos"])) - - return rep - - -# ---------------------------------------------------------------- 反自证 - -def self_test(): - """🔴 **反自证**:造几种已知漂移 ⇒ 必须被抓到;再验一遍真实契约**没有**漂移。 - - 永远返回「干净」的尺子 = 没有尺子 ⇒ 这一段是尺子可信的前提。 - """ - contract = os.path.join(ROOT, "docs", "contract.md") - src_dir = os.path.join(ROOT, "src", "backend", "src") - if not os.path.isfile(contract): - sys.stderr.write("check-contract-scan: 找不到契约 %s\n" % contract) - return 2 - - base = analyze(contract, src_dir) - drifts = [c for c in base.checks if c[1] == "DRIFT"] - if drifts: - for cid, _s, detail in drifts: - sys.stderr.write("check-contract-scan: 真实契约就有漂移(%s: %s)\n" % (cid, detail)) - return 1 - - with io.open(contract, encoding="utf-8") as fh: - text = fh.read() - - def mutate(fn): - return fn(text) - - cases = [] - - def add_row(t): - return t.replace("[ENDPOINT]\n", "[ENDPOINT]\nA\tGET\t/api/zzz/Fake/List\t登录\tplatform\n", 1) - - def drop_row(t): - return t.replace("A\tGET\t/api/health\t无\tplatform\n", "", 1) - - def bad_method(t): - return t.replace("A\tGET\t/api/health\t无\tplatform\n", - "A\tPOST\t/api/health\t无\tplatform\n", 1) - - def bad_guard(t): - return t.replace("A\tGET\t/api/ssw/sys/User/List\tsystem/User\tplatform\n", - "A\tGET\t/api/ssw/sys/User/List\t登录\tplatform\n", 1) - - def bad_owner(t): - return t.replace("A\tGET\t/api/ssw/demo/DemoItem/List\t登录\tdemo\n", - "A\tGET\t/api/ssw/demo/DemoItem/List\t登录\tplatform\n", 1) - - def bad_face(t): - return t.replace("A\t25\t面 A 专属", "A\t24\t面 A 专属", 1) - - # ---- CC10 的三类漂移(官方端点台账 ↔ 代码真实路由)---- - def off_says_absent(t): - # 台账把「代码里有」的端点说成未实现 - return t.replace( - "GET\t/api/permission/Users\timplemented\t", - "GET\t/api/permission/Users\tabsent\t", 1) - - def off_fake_path(t): - # 台账说已实现,但那条路径代码里根本没有 - return t.replace( - "GET\t/api/system/Menu/ModuleBySystem\timplemented\t", - "GET\t/api/system/Menu/ModuleBySystemXX\timplemented\t", 1) - - def off_drop_row(t): - # 代码里有面 B 路由,但台账里没记账("实现了但没记账") - return t.replace( - "GET\t/api/permission/Role\timplemented\tRoleController.java:99-100\t" - "面 B 已落地:PageListVO 形状\n", "", 1) - - cases.append(("契约多一条端点", add_row, "CC3")) - cases.append(("契约少一条端点", drop_row, "CC2")) - cases.append(("方法写错", bad_method, "CC3")) - cases.append(("守卫写错", bad_guard, "CC6")) - cases.append(("归属层写错", bad_owner, "CC5")) - cases.append(("契约面计数写错", bad_face, "CC9")) - cases.append(("台账把已实现的端点说成未实现", off_says_absent, "CC10")) - cases.append(("台账写了代码里没有的端点", off_fake_path, "CC10")) - cases.append(("面 B 路由没记账", off_drop_row, "CC10")) - - failed = 0 - for name, fn, expect in cases: - mutated = mutate(fn) - if mutated == text: - sys.stderr.write("check-contract-scan: 反自证用例「%s」改不动契约(锚点没了)\n" % name) - failed += 1 - continue - tmpdir = tempfile.mkdtemp(prefix="cc-selftest-") - tmp = os.path.join(tmpdir, "contract.md") - with io.open(tmp, "w", encoding="utf-8") as fh: - fh.write(mutated) - try: - rep = analyze(tmp, src_dir) - except Exception as exc: # noqa: BLE001 - sys.stderr.write("check-contract-scan: 反自证用例「%s」分析异常:%s\n" % (name, exc)) - failed += 1 - continue - finally: - shutil.rmtree(tmpdir, ignore_errors=True) - hit = [c for c in rep.checks if c[0] == expect and c[1] == "DRIFT"] - if hit: - print(" ✅ 反自证「%s」被 %s 抓到" % (name, expect)) - else: - print(" ❌ 反自证「%s」**没**被 %s 抓到(尺子被改弱了?)" % (name, expect)) - failed += 1 - - if failed: - sys.stderr.write("check-contract-scan: 反自证失败 %d 例\n" % failed) - return 1 - print("反自证 %d 例全部通过(真实契约零漂移 + 每种注入漂移都被抓到)" % len(cases)) - return 0 - - -def main(argv): - if "--self-test" in argv: - return self_test() - - contract = os.path.join(ROOT, "docs", "contract.md") - src_dir = os.path.join(ROOT, "src", "backend", "src") - i = 1 - while i < len(argv): - if argv[i] == "--contract" and i + 1 < len(argv): - contract = argv[i + 1] - i += 2 - continue - if argv[i] == "--src" and i + 1 < len(argv): - src_dir = argv[i + 1] - i += 2 - continue - sys.stderr.write("check-contract-scan: 未知参数 %r\n" % argv[i]) - return 2 - - try: - rep = analyze(contract, src_dir) - except contract_expect.ContractError as exc: - sys.stderr.write("check-contract-scan: %s\n" % exc) - return 2 - for line in rep.lines(): - print(line) - return 0 - - -if __name__ == "__main__": - sys.exit(main(sys.argv)) diff --git a/scripts/check-contract.sh b/scripts/check-contract.sh deleted file mode 100644 index cceec45..0000000 --- a/scripts/check-contract.sh +++ /dev/null @@ -1,168 +0,0 @@ -#!/usr/bin/env bash -# ssw-jnpf-lite-rust 契约对账尺子 —— `docs/contract.md` ↔ 代码里的真实路由 -# -# 目的:把「契约文档」和「代码」这两份**独立**的真相**对账**。 -# 契约 §6 的端点表原先是**散文表格**,代码里的路由注册是**另一处** -# ⇒ 加端点 / 改路径 / 改守卫 ⇒ 各改各的 ⇒ 漂移没人发现。 -# 本尺子把契约附录 A 的 `[ENDPOINT]`(机器可读)与代码里**真实注册**的路由 -# **双向**逐条对账:契约多 / 代码多 / 方法不符 / 归属层不符 / 守卫不符。 -# -# 🔴 **纯静态**:不启动后端、不发请求。只需要 `python3`(macOS 自带)。 -# -# 用法: -# bash scripts/check-contract.sh # 无参 ⇒ 全查 -# bash scripts/check-contract.sh --help # 本用法 -# -# 退出码:0 全过 / 1 有 ❌ 项 / 2 用法错或前置错误 -# -# ── 判据(CC1–CC10)── -# CC2 端点**总数**一致(契约 N 条 == 代码 N 条) -# CC3 契约 → 代码:每条端点在代码里存在且**方法**一致 -# CC4 代码 → 契约:代码里没有契约未登记的端点 -# CC5 **归属层**一致(platform / 业务模块代号) -# CC6 **守卫**一致(面A 菜单 key / 面B 点权限编码 / 登录 / 无)——静态推导 -# CC7 钉子测试的**字面量清单**(REGISTERED / JNPF_REGISTERED)与平台层路由双向覆盖 -# CC8 业务路由**三处**一致(各模块 ROUTES 常量 / router() 注册 / ALL_ROUTES) -# CC9 契约面计数**自洽**([FACE] 登记的条数 == [ENDPOINT] 里各 face 的实际条数) -# CC10 **官方端点台账** ↔ 代码真实路由(双向)+ 打印「官方端点覆盖 N/M」 -# CC1' **反自证**:注入已知漂移 ⇒ 必须被抓到(永远返回「干净」的尺子 = 没有尺子) -# -# 🔴 **期望值来自 `docs/contract.md` 附录 A**(机器可读)⇒ 改契约只改那一处。 - -set -u - -ROOT="$(cd "$(dirname "$0")/.." && pwd)" -SCRIPTS="$ROOT/scripts" -CONTRACT="$ROOT/docs/contract.md" -SRC="$ROOT/src/backend/src" -SCAN="$SCRIPTS/check-contract-scan.py" -CE_PY="$SCRIPTS/contract_expect.py" - -usage() { - echo "用法: bash scripts/check-contract.sh" - echo " 纯静态对账「契约端点表 ↔ 代码里真实注册的路由」" - echo "退出码: 0 全过 / 1 有 ❌ / 2 用法错或前置错误" -} - -if [ "${1:-}" = "-h" ] || [ "${1:-}" = "--help" ]; then - usage - exit 0 -fi -if [ "$#" -ne 0 ]; then - echo "❌ 未知参数: ${1}" - usage - exit 2 -fi - -# ---- 前置:python3 / 扫描器 / 契约文件 ---- -PY_BIN="${PY_BIN-$(command -v python3 2>/dev/null || true)}" -if [ -z "${PY_BIN}" ]; then - echo "❌ 找不到 python3(扫描器需要它)" - exit 2 -fi -if [ ! -f "${SCAN}" ]; then - echo "❌ 缺扫描器: ${SCAN}" - exit 2 -fi -if [ ! -f "${CE_PY}" ]; then - echo "❌ 缺契约期望值读取器: ${CE_PY}" - exit 2 -fi -if [ ! -f "${CONTRACT}" ]; then - echo "❌ 缺契约文件: ${CONTRACT}" - exit 2 -fi - -# ---- 契约期望值(唯一真源:docs/contract.md 附录 A)---- -CE_RULER_ROWS="$("${PY_BIN}" "${CE_PY}" rows RULER 2>/dev/null)" || CE_RULER_ROWS="" -if [ -z "${CE_RULER_ROWS}" ]; then - echo "❌ 读契约期望值失败(docs/contract.md 附录 A 是不是被改坏了?)" - exit 2 -fi -CE_EXP_ASSERTIONS="$(printf '%s\n' "${CE_RULER_ROWS}" | awk -F'\t' '$1=="check-contract.sh" { print $2; exit }')" - -PASS=0; FAIL=0 -ok() { echo " ✅ $1"; PASS=$((PASS+1)); } -no() { echo " ❌ $1"; FAIL=$((FAIL+1)); } -hdr() { echo; echo "── $1 ──"; } - -# ---- 跑扫描器 ---- -SCAN_OUT="$("${PY_BIN}" "${SCAN}" --contract "${CONTRACT}" --src "${SRC}" 2>&1)" -SCAN_RC=$? -if [ "${SCAN_RC}" -eq 2 ]; then - echo "❌ 扫描器前置失败(契约读不出来 / 参数错):" - printf '%s\n' "${SCAN_OUT}" | sed 's/^/ /' - exit 2 -fi - -hdr "[CC2–CC10] 契约端点表 ↔ 代码真实路由 逐条对账" -DRIFT_LINES="" -while IFS=$'\t' read -r kind f1 f2 f3; do - [ -z "${kind:-}" ] && continue - case "${kind}" in - CHECK) - if [ "${f2}" = "OK" ]; then - ok "${f1}:${f3}" - else - no "${f1}:${f3}" - fi - ;; - INFO) - # 🔴 进度信息(官方端点覆盖 N/M)—— **不计入** PASS/FAIL - echo " 📊 ${f1}:${f2}" - ;; - WARN) - # WARN 行只有 3 列(kind / id / 说明)⇒ 说明在 f2 - if [ -n "${f3}" ]; then - DRIFT_LINES="${DRIFT_LINES}${f1}:${f3}"$'\n' - else - DRIFT_LINES="${DRIFT_LINES}${f1}:${f2}"$'\n' - fi - ;; - esac -done <<< "${SCAN_OUT}" - -if [ -n "${DRIFT_LINES}" ]; then - hdr "漂移明细" - printf '%s' "${DRIFT_LINES}" | sed 's/^/ ⚠️ /' -fi - -# ---- CC1' 反自证:尺子自己必须能抓到漂移 ---- -hdr "[CC1'] 扫描器反自证(--self-test 必须过)" -SELFTEST_OUT="$("${PY_BIN}" "${SCAN}" --self-test 2>&1)" -if [ "$?" -eq 0 ]; then - ok "扫描器自证通过:${SELFTEST_OUT}" -else - no "扫描器自证失败:${SELFTEST_OUT}" -fi - -# -------- 尺子自证:跑出来的条数必须等于契约里登记的条数 -------- -# -# 🔴 尺子自己知道它断言了几条(PASS+FAIL)。哪天有人删掉几条断言、或者某个分支提前 -# return 了,尺子照样「全绿」—— 变弱的尺子比没有尺子更危险 ⇒ 条数由**契约**钉死。 -hdr "[自证] 尺子条数与契约登记一致" -if [ -n "${CE_EXP_ASSERTIONS}" ]; then - CE_ACT_ASSERTIONS=$((PASS + FAIL)) - if [ "${CE_ACT_ASSERTIONS}" -eq "${CE_EXP_ASSERTIONS}" ]; then - # 自证**不计入** PASS/FAIL(它是元断言,不是业务断言) - echo " ✅ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言 = 契约登记的 ${CE_EXP_ASSERTIONS} 条" - else - echo " ❌ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言,契约登记 ${CE_EXP_ASSERTIONS} 条 ⇒ 尺子被改弱了(少了/多了断言)" - FAIL=$((FAIL + 1)) - fi -else - echo " ❌ 契约 [RULER] 里没有登记 check-contract.sh 的期望条数" - FAIL=$((FAIL + 1)) -fi - -# -------- 总结 -------- -echo -echo "── 总结 ──" -echo "PASS=${PASS} FAIL=${FAIL}" -if [ "${FAIL}" -eq 0 ]; then - echo "全 ✅ 契约与代码没漂移" -else - echo "有 ❌,请按上面修复(改契约 ⇒ 改 docs/contract.md 附录 A 的 [ENDPOINT])" -fi - -exit $([ "${FAIL}" -eq 0 ] && echo 0 || echo 1) diff --git a/scripts/check-module.sh b/scripts/check-module.sh deleted file mode 100755 index 9d4a779..0000000 --- a/scripts/check-module.sh +++ /dev/null @@ -1,556 +0,0 @@ -#!/usr/bin/env bash -# ssw-jnpf-lite-rust 加业务模块的「接触点」静态自检(Rust 版) -# -# 目的:在跑 perm-smoke 之前,**快速发现漏改的文件或字符串不一致**——这类问题一旦漏掉, -# 表现是「菜单不显示」「页面 404」「权限静默放行」,非常难定位。 -# -# 🔴 **10 个接触点**(每个业务模块都要碰这 10 处): -# ① 业务模块文件 + 3 条路由 ② spec 定义 ③ 实体表 DDL ④ 守卫 module_key -# ⑤ 前端 api 文件 ⑥ 前端页面 ⑦ 前端路由 ⑧ **菜单声明**(`*_MENU`) -# ⑨ **菜单登记**(`ALL_MENUS`) ⑩ 三处一字不差(module_key == url_address == Route path) -# -# 🔴 **纯静态**:不启动后端、不发一个请求、不依赖 node(契约明令:后端与冒烟脚本零 node 依赖)。 -# ⇒ 用法里**没有** `--live`;传了未知参数 ⇒ 退出码 2(用法错)。 -# -# 🔴 **期望值的唯一真源 = `docs/contract.md` 附录 A**(机器可读区段 `[MODULE]` / `[MENU]` / -# `[RULER]`,由 `scripts/contract_expect.py` 解析)。 -# 本脚本**不再硬编码**表名 / 路由 / 菜单 id ⇒ -# ① 改契约(加模块、改菜单)⇒ 只改 contract.md 一处; -# ② 代码漂移 ⇒ 本脚本立刻报「与契约不一致」(不是默默放过)。 -# -# 用法: -# bash scripts/check-module.sh # 无参 ⇒ 检查契约里登记的全部业务模块 -# bash scripts/check-module.sh # 也可只查一个(如 books Book) -# bash scripts/check-module.sh --help # 本用法 -# -# 例: -# bash scripts/check-module.sh # demo / shop / books 全查 -# bash scripts/check-module.sh books Book # 单模块 -# -# 退出码:0 全过 / 1 有 ❌ 项 / 2 用法错 - -# 🔴 **故意只用 `set -u`,不加 `-e` / `pipefail`** —— 这是有意的取舍,不是漏写: -# 本脚本的判定**依赖 grep 的返回码**(grep 命中 ⇒ 记一条 ✅,不命中 ⇒ 记一条 ❌)。 -# 若加 `-e`,**第一条没命中的 grep 就会中止整个脚本** ⇒ 闸门只跑了一半就“静默变绿/变红”, -# 反而把闸门弄坏。加 `pipefail` 同理(管道里任一段非 0 都会中止)。 -# ⇒ 想要「失败即停」请自己看末尾的 `PASS=` / `FAIL=` 与退出码。 -set -u - -ROOT="$(cd "$(dirname "$0")/.." && pwd)" - -BACKEND="$ROOT/src/backend" -MODULES_DIR="$BACKEND/src/modules" -MODULES_MOD="$MODULES_DIR/mod.rs" -ROUTES="$BACKEND/src/routes.rs" -SCHEMA="$BACKEND/db/schema.sql" -CRUD="$BACKEND/src/platform/crud.rs" -FE="$ROOT/src/frontend" - -# ---- 契约期望值(唯一真源:docs/contract.md 附录 A)---- -CE_PY="$ROOT/scripts/contract_expect.py" -if ! command -v python3 >/dev/null 2>&1; then - echo "❌ 前置错误:找不到 python3(读契约期望值用)。" - exit 2 -fi -if [ ! -f "$CE_PY" ]; then - echo "❌ 前置错误:找不到 ${CE_PY}。" - exit 2 -fi -ce() { python3 "${CE_PY}" "$@"; } - -# 一次取全表(表头行 + 数据行,制表符分隔) -CE_MOD_ROWS="$(ce rows MODULE 2>/dev/null)" || { - echo "❌ 前置错误:读契约的 [MODULE] 区段失败(docs/contract.md 的附录 A 是不是被改坏了?)。" - exit 2 -} -CE_MENU_ROWS="$(ce rows MENU 2>/dev/null)" || { - echo "❌ 前置错误:读契约的 [MENU] 区段失败(docs/contract.md 的附录 A 是不是被改坏了?)。" - exit 2 -} -CE_RULER_ROWS="$(ce rows RULER 2>/dev/null)" || { - echo "❌ 前置错误:读契约的 [RULER] 区段失败(docs/contract.md 的附录 A 是不是被改坏了?)。" - exit 2 -} - -# 从「表头行 + 数据行」里按首列取某列的值;找不到 ⇒ 返回空 + 非 0 -# -# 🔴 用 awk(-F'\t')而**不是** bash `read`:bash 的 `read` 按 IFS 空白折叠连续分隔符, -# 会把**空字段**(如 MENU.icon = NULL)吃掉 ⇒ 读出来错位。awk 保留空字段。 -row_field() { - local rows="$1" key="$2" col="$3" - printf '%s\n' "${rows}" | awk -F'\t' -v key="${key}" -v col="${col}" ' - NR == 1 { for (i = 1; i <= NF; i++) if ($i == col) c = i; next } - $1 == key { print $c; found = 1; exit } - END { if (!found) exit 3 } - ' -} - -usage() { - echo "用法: bash scripts/check-module.sh [ ...]" - echo " 无参 ⇒ 检查全部三个业务模块(demo / shop / books)" - echo "例: bash scripts/check-module.sh" - echo " bash scripts/check-module.sh books Book" - echo "退出码: 0 全过 / 1 有 ❌ 项 / 2 用法错" -} - -if [ "${1:-}" = "-h" ] || [ "${1:-}" = "--help" ]; then - usage - exit 0 -fi - -# ---- 目标清单:appCode:Entity(默认取**契约** [MODULE] 区段登记的全部模块)---- -CE_ALL_TARGETS="$(printf '%s\n' "${CE_MOD_ROWS}" | awk -F'\t' 'NR>1 { print $1 ":" $2 }')" -TARGETS=() -if [ "$#" -eq 0 ]; then - while IFS= read -r line; do - [ -n "${line}" ] || continue - TARGETS+=("${line}") - done <<< "${CE_ALL_TARGETS}" -else - APP_ARG="$1" - shift - if [ "$#" -eq 0 ]; then - echo "❌ 用法错: 后面至少要跟一个 " - usage - exit 2 - fi - for ENT_ARG in "$@"; do - case "${ENT_ARG}" in - -*) - echo "❌ 未知参数: ${ENT_ARG}" - usage - exit 2 - ;; - esac - TARGETS+=("${APP_ARG}:${ENT_ARG}") - done -fi - -# ---- 期望值表(**逐字来自契约** `docs/contract.md` 附录 A 的 `[MODULE]` 区段)---- -# 每个目标:表名 / urlAddress(= 前端 Route path)/ 菜单 id / module_key(None = 仅登录) -# / **前端 api 文件该有没有**(有 = 有 / 无 = 走 view 直连分支) -# / **业务模块文件**(`src/backend/src/modules/.rs` —— spec + handler + 路由) -# -# 🔴 **新增业务模块时**:在契约 `[MODULE]` 加一行 + 在 `[MENU]` 加一行 ⇒ 本脚本自动覆盖它。 -# (本脚本**不再硬编码**任何业务标识符 ⇒ 加模块不用改脚本。) -T_COUNT=${#TARGETS[@]} -T_APP=(); T_ENT=(); T_TABLE=(); T_ROUTE=(); T_SEED=(); T_MK=(); T_API=(); T_FILE=() -for T in "${TARGETS[@]}"; do - A="${T%%:*}" - E="${T##*:}" - C_ENT="$(row_field "${CE_MOD_ROWS}" "${A}" entity)" - C_TABLE="$(row_field "${CE_MOD_ROWS}" "${A}" table)" - C_URL="$(row_field "${CE_MOD_ROWS}" "${A}" urlAddress)" - C_MK="$(row_field "${CE_MOD_ROWS}" "${A}" moduleKey)" - C_MENU="$(row_field "${CE_MOD_ROWS}" "${A}" menuId)" - C_API="$(row_field "${CE_MOD_ROWS}" "${A}" apiFile)" - C_FILE="$(row_field "${CE_MOD_ROWS}" "${A}" rsFile)" - if [ -z "${C_FILE}" ] || [ -z "${C_TABLE}" ]; then - echo "❌ 契约的 [MODULE] 区段里没有 app=${A} 这一行。" - echo " 本仓已知: $(printf '%s\n' "${CE_ALL_TARGETS}" | tr '\n' ' ')" - echo " ⇒ 新增模块请在 docs/contract.md 附录 A 的 [MODULE] 与 [MENU] 里各加一行。" - exit 2 - fi - if [ "${C_ENT}" != "${E}" ]; then - echo "❌ 契约里 app=${A} 的 entity 是 ${C_ENT},你传的是 ${E}" - exit 2 - fi - T_APP+=("${A}"); T_ENT+=("${E}") - T_TABLE+=("${C_TABLE}"); T_ROUTE+=("${C_URL}") - T_SEED+=("${C_MENU}"); T_MK+=("${C_MK}") - T_API+=("${C_API}"); T_FILE+=("${C_FILE}") -done - -PASS=0; FAIL=0 -ok() { echo " ✅ $1"; PASS=$((PASS+1)); } -no() { echo " ❌ $1"; FAIL=$((FAIL+1)); } -hdr() { echo; echo "── $1 ──"; } - -# 小写(兼容 bash 3.x,不用 ${var,,}) -lower() { printf '%s' "$1" | tr '[:upper:]' '[:lower:]'; } - -# 自然英语复数(兼容 bash 3.x,不依赖 declare -A) -# Apply → Applies / Box → Boxes / Match → Matches / Buy → Buys(y 辅音前) / Boy → Boys -plural() { - case "$1" in - *s|*x|*ch|*sh) echo "${1}es" ;; # -s/-x/-ch/-sh 直接加 es - *ay|*ey|*oy|*uy) echo "${1}s" ;; # 单元音 + y → 保留 +s(Boy → Boys) - *y) echo "${1%y}ies" ;; # 辅音 + y → 去 y 加 ies - *) echo "${1}s" ;; # 默认 +s - esac -} - -# 从业务模块文件里取该模块的 spec 常量名(如 DEMO_SPEC / PRODUCT_SPEC / BOOK_SPEC) -spec_const_of() { - awk ' - /pub const [A-Z_]+_SPEC: EntitySpec/ { - n = $0; sub(/.*pub const /, "", n); sub(/: EntitySpec.*/, "", n); print n; exit - } - ' "$1" -} - -# 从业务模块文件里取某个 spec 的 table 字面量 -spec_table_of() { - awk -v want="$1" ' - /entity: "/ { e = $0; sub(/.*entity: "/, "", e); sub(/".*/, "", e) } - /table: "/ { t = $0; sub(/.*table: "/, "", t); sub(/".*/, "", t); - if (e == want) { print t; exit } } - ' "$2" -} - -# 从业务模块文件里取某个 spec 的 module_key(None 或 Some("x") 的 x) -spec_module_key_of() { - awk -v want="$1" ' - /entity: "/ { e = $0; sub(/.*entity: "/, "", e); sub(/".*/, "", e) } - /module_key:/ { - m = $0; sub(/.*module_key:[[:space:]]*/, "", m); sub(/,[[:space:]]*$/, "", m) - if (e == want) { - if (m ~ /^Some\(/) { s = m; sub(/^Some\("/, "", s); sub(/"\)$/, "", s); print s } - else print "None" - exit - } - } - ' "$2" -} - -# 从业务模块文件的 MenuSpec 块里取该模块声明的**菜单 id** -# -# 🔴 **正则必须锚到行首的 `id:`** —— 否则 `parent_id: "0"` 里的 `id:` 会被误取。 -menu_id_of() { - awk ' - /^[ \t]*id:[ \t]*"/ { s = $0; sub(/^[ \t]*id:[ \t]*"/, "", s); sub(/".*/, "", s); print s; exit } - ' "$1" -} - -# 从业务模块文件的 MenuSpec 块里取**某个菜单 id 的某个字段** -# -# menu_field_of -# field ∈ id | full_name | en_code | url_address | parent_id | menu_type | icon | sort_code -# `Some("x")` ⇒ `x`;`None` ⇒ `None`;字符串去引号;数字原样。 -menu_field_of() { - awk -v want="$1" -v field="$2" ' - /^[ \t]*id:[ \t]*"/ { - cur = $0; sub(/^[ \t]*id:[ \t]*"/, "", cur); sub(/".*/, "", cur) - } - cur == want { - key = $0; sub(/^[ \t]*/, "", key); sub(/:.*$/, "", key) - if (key == field) { - val = $0; sub(/^[ \t]*[A-Za-z_]+:[ \t]*/, "", val); gsub(/,$/, "", val) - if (val ~ /^Some\(/) { sub(/^Some\("/, "", val); sub(/"\)$/, "", val) } - else { sub(/^"/, "", val); sub(/"$/, "", val) } - print val; exit - } - } - ' "$3" -} - -menu_url_of() { menu_field_of "$1" url_address "$2"; } - -# 逐字核对「代码里声明的菜单字段」与「契约 [MENU] 里那一行」 -# check_menu_field <契约列名> <代码字段名> -check_menu_field() { - local mid="$1" ccol="$2" cfield="$3" cval dval - cval="$(row_field "${CE_MENU_ROWS}" "${mid}" "${ccol}")" - dval="$(menu_field_of "${mid}" "${cfield}" "$MODFILE_CUR")" - if [ "${cval}" = "${dval}" ]; then - ok "菜单 ${mid}.${ccol} = ${cval}" - else - no "菜单 ${mid}.${ccol} = ${dval:-(没取到)},契约期望 ${cval:-(NULL)}" - fi -} - -# 从 schema.sql 里取某张表的 CREATE TABLE 块 -schema_block_of() { - awk -v t="$1" ' - $0 ~ ("CREATE TABLE " t " \\(") { inb = 1 } - inb { print } - inb && /^\);/ { exit } - ' "$SCHEMA" -} - -for i in $(seq 0 $((T_COUNT - 1))); do - APP="${T_APP[$i]}" - ENT="${T_ENT[$i]}" - TABLE="${T_TABLE[$i]}" - ROUTE="${T_ROUTE[$i]}" - SEED_ID="${T_SEED[$i]}" - MK="${T_MK[$i]}" - API_EXP="${T_API[$i]}" - MODFILE="$MODULES_DIR/${T_FILE[$i]}" - MODFILE_CUR="${MODFILE}" # 供 check_menu_field 用(bash 没有闭包,只能走全局) - MODNAME="${T_FILE[$i]%.rs}" - LC="$(lower "$ENT")" - URL="${APP}/${ENT}" - - hdr "[${ENT}] 1) 后端路由注册:modules/${T_FILE[$i]} 含 /api/ssw/${URL}/{List|Save|Delete}" - if [ -f "$MODFILE" ]; then - ok "业务模块文件存在: src/backend/src/modules/${T_FILE[$i]}" - else - no "缺业务模块文件: src/backend/src/modules/${T_FILE[$i]}" - fi - for ep in List Save Delete; do - if grep -q "/api/ssw/${URL}/${ep}" "$MODFILE" 2>/dev/null; then - ok "modules/${T_FILE[$i]} 已注册 /api/ssw/${URL}/${ep}" - else - no "modules/${T_FILE[$i]} 缺 /api/ssw/${URL}/${ep} → 端点 404" - fi - done - # 🔴 **业务路由不许进平台层** —— 平台层只 merge 一次(`modules::router()`)。 - # 只看**真正的注册调用**(`.route("…")`)—— routes.rs 的路由表钉子测试里 - # 有一份**路径清单**(那是契约快照,不是注册)⇒ 不能拿它当判据。 - if grep -qE "\.route\(\"/api/ssw/${URL}/" "$ROUTES" 2>/dev/null; then - no "routes.rs 里注册了业务路由 /api/ssw/${URL}/ ⇒ 平台层混进了业务知识" - else - ok "routes.rs 未注册业务路由(平台层只 merge modules::router())" - fi - # 🔴 **模块必须被业务层登记表收编** —— `modules/mod.rs` 的 `router()` 要 merge 它、 - # `ALL_SPECS` 要收它的 spec(漏一处 ⇒ 端点 404 / 启动自检报错)。 - if grep -q "${MODNAME}::router()" "$MODULES_MOD" 2>/dev/null; then - ok "modules/mod.rs 的 router() merge 了 ${MODNAME}::router()" - else - no "modules/mod.rs 的 router() 没 merge ${MODNAME}::router() ⇒ 端点 404" - fi - SPEC_CONST="$(spec_const_of "$MODFILE")" - if [ -n "${SPEC_CONST}" ] && grep -q "${SPEC_CONST}" "$MODULES_MOD" 2>/dev/null; then - ok "modules/mod.rs 的 ALL_SPECS 收了 ${SPEC_CONST}" - else - no "modules/mod.rs 的 ALL_SPECS 没收 ${SPEC_CONST:-(没取到 spec 常量)} ⇒ 启动白名单自检会失败" - fi - - hdr "[${ENT}] 2) spec 定义:modules/${T_FILE[$i]} 含 entity: \"${ENT}\" + table: \"${TABLE}\"" - if grep -q "entity: \"${ENT}\"" "$MODFILE" 2>/dev/null; then - ok "modules/${T_FILE[$i]} 含 entity: \"${ENT}\"" - else - no "modules/${T_FILE[$i]} 缺 entity: \"${ENT}\"(spec 没登记这个实体)" - fi - SPEC_TABLE="$(spec_table_of "${ENT}" "$MODFILE")" - if [ "${SPEC_TABLE}" = "${TABLE}" ]; then - ok "spec.table = ${TABLE}" - else - no "spec.table = ${SPEC_TABLE:-(没取到)},期望 ${TABLE}" - fi - - hdr "[${ENT}] 3) 实体表存在:schema.sql 含 CREATE TABLE ${TABLE}" - if grep -q "CREATE TABLE ${TABLE}" "$SCHEMA" 2>/dev/null; then - ok "schema.sql 有表 ${TABLE}" - else - no "schema.sql 缺表 ${TABLE} → 业务模块跑不起来" - fi - - hdr "[${ENT}] 4) 守卫 module_key:modules/${T_FILE[$i]} 的 spec.module_key" - SPEC_MK="$(spec_module_key_of "${ENT}" "$MODFILE")" - if [ "${SPEC_MK}" = "${MK}" ]; then - ok "spec.module_key = ${MK}" - else - no "spec.module_key = ${SPEC_MK:-(没取到)},期望 ${MK}" - fi - - hdr "[${ENT}] 5) 前端 api 文件:api/${LC}.ts 含 list/save/delete 三导出(期望:${API_EXP})" - API="$FE/src/api/${LC}.ts" - VIEW="$FE/src/views/${ENT}.tsx" - if [ "${API_EXP}" = "有" ]; then - # 期望**有** api 文件 ⇒ 缺文件就是 ❌(**不许**再打「无 api/xxx.ts」这种误导性绿灯)。 - if [ -f "$API" ]; then - # 命名约定:list 函数走「自然英语复数」(Book → listBooks / Product → listProducts) - # save/delete 用 Entity 单数(PascalCase),与后端端点命名一致。 - PLURAL_ENT="$(plural "$ENT")" - for fn in "list${PLURAL_ENT}" "save${ENT}" "delete${ENT}"; do - if grep -qE "export[[:space:]]+const[[:space:]]+${fn}" "$API" 2>/dev/null; then - ok "${fn} 导出存在" - else - no "${API} 缺 export const ${fn}(前端解构会 undefined)" - fi - done - else - no "缺 api/${LC}.ts(期望有:${ENT} 的前端必须有 api 层)" - fi - else - # 期望**无** api 文件 ⇒ 本仓前端是逐字复制:demo 模块没有 api 文件, - # views/DemoItem.tsx 直接 request.get('/ssw/demo/DemoItem/List') ⇒ - # 「前端 api 文件」这一接触点对 demo 走**直连分支**(两种都查不到才算 ❌)。 - if [ -f "$API" ]; then - no "多出 api/${LC}.ts(期望无:${ENT} 走 view 直连分支)—— 请同步期望值表" - else - ok "无 api/${LC}.ts(期望无 ⇒ 走 view 直连分支)" - if [ -f "$VIEW" ]; then - for ep in List Save Delete; do - if grep -qE "request\.(get|post|delete)\([^)]*/ssw/${URL}/${ep}" "$VIEW" 2>/dev/null; then - ok "views/${ENT}.tsx 直连 request → /ssw/${URL}/${ep}" - else - no "views/${ENT}.tsx 没有直连 request → /ssw/${URL}/${ep}" - fi - done - else - no "views/${ENT}.tsx 不存在,无法核对直连分支" - fi - fi - fi - - hdr "[${ENT}] 6) 前端页面:views/${ENT}.tsx 存在" - if [ -f "$VIEW" ]; then - ok "views/${ENT}.tsx" - else - no "缺文件: views/${ENT}.tsx" - fi - - hdr "[${ENT}] 7) 前端路由:App.tsx 含 ),BSD grep 不支持 -P 跨行匹配, - # 用 tr 把换行去掉再 grep 最稳。 - if tr '\n' ' ' < "$FE/src/App.tsx" | grep -q "]*path=\"/${ROUTE}\"" 2>/dev/null; then - ok "Route path=\"/${ROUTE}\" 已注册" - else - no "App.tsx 缺 .rs` 的 - # `*_MENU: MenuSpec` 里,由装配根注入平台层的种子。 - # 期望值来自**契约** `[MENU]` 区段 ⇒ 代码改了菜单名/编码/图标 ⇒ 这里立刻报漂移。 - DECL_ID="$(menu_id_of "${MODFILE}")" - if [ "${DECL_ID}" = "${SEED_ID}" ]; then - ok "modules/${T_FILE[$i]} 声明的菜单 id = ${SEED_ID}" - else - no "modules/${T_FILE[$i]} 声明的菜单 id = ${DECL_ID:-(没取到)},期望 ${SEED_ID}" - fi - SEED_URL="$(menu_url_of "${SEED_ID}" "${MODFILE}")" - if [ "${SEED_URL}" = "${ROUTE}" ]; then - ok "菜单 ${SEED_ID}.url_address = ${ROUTE}" - else - no "菜单 ${SEED_ID}.url_address = ${SEED_URL:-(没取到)},期望 ${ROUTE} → 菜单不显示" - fi - # 契约 [MENU] 里这一行的其余字段,逐字核对 - check_menu_field "${SEED_ID}" fullName full_name - check_menu_field "${SEED_ID}" enCode en_code - check_menu_field "${SEED_ID}" parentId parent_id - check_menu_field "${SEED_ID}" type menu_type - check_menu_field "${SEED_ID}" sortCode sort_code - # icon:契约里空 = NULL,代码里写 `None` ⇒ 归一化后再比 - C_ICON="$(row_field "${CE_MENU_ROWS}" "${SEED_ID}" icon)" - D_ICON="$(menu_field_of "${SEED_ID}" icon "${MODFILE}")" - if [ "${D_ICON}" = "None" ]; then D_ICON=""; fi - if [ "${C_ICON}" = "${D_ICON}" ]; then - ok "菜单 ${SEED_ID}.icon = ${C_ICON:-(NULL)}" - else - no "菜单 ${SEED_ID}.icon = ${D_ICON:-(NULL)},契约期望 ${C_ICON:-(NULL)}" - fi - - hdr "[${ENT}] 9) 菜单登记:modules/mod.rs 的 ALL_MENUS 收了本模块的菜单" - MENU_CONST="$(grep -o "^pub const [A-Z_]*_MENU: MenuSpec" "${MODFILE}" 2>/dev/null | sed 's/^pub const //; s/: MenuSpec$//')" - if [ -z "${MENU_CONST}" ]; then - no "modules/${T_FILE[$i]} 没有 *_MENU: MenuSpec 声明" - elif grep -q "${MENU_CONST}," "${MODULES_MOD}" 2>/dev/null; then - ok "modules/mod.rs 的 ALL_MENUS 收了 ${MENU_CONST}" - else - no "modules/mod.rs 的 ALL_MENUS 没收 ${MENU_CONST} ⇒ 菜单不会被种、admin 少一条授权" - fi - - hdr "[${ENT}] 10) 三处一字不差:module_key == url_address == Route path(去前导斜杠)" - if [ "${MK}" = "None" ]; then - # 🔴 demo 是「仅登录」守卫 ⇒ **没有** module_key 这一侧 ⇒ 只比 url_address == Route path。 - if [ "${SEED_URL}" = "${ROUTE}" ]; then - ok "url_address == Route path:${SEED_URL} == ${ROUTE}(demo 仅登录 ⇒ 跳过 module_key 侧)" - else - no "url_address=${SEED_URL:-无} / Route=${ROUTE} 不一致" - fi - elif [ "${SPEC_MK}" = "${SEED_URL}" ] && [ "${SEED_URL}" = "${ROUTE}" ]; then - ok "三处相等:${SPEC_MK} == ${SEED_URL} == ${ROUTE}" - else - no "三处不一致:module_key=${SPEC_MK:-无} / url_address=${SEED_URL:-无} / Route=${ROUTE}" - fi - - hdr "[${ENT}] 实体列 f_ 前缀 + 主键 f_id VARCHAR(50)(契约红线 4)" - BLOCK="$(schema_block_of "${TABLE}")" - if [ -z "${BLOCK}" ]; then - no "schema.sql 里没解析出 ${TABLE} 的建表块" - else - COLS="$(printf '%s\n' "${BLOCK}" | sed -n 's/^ \([A-Za-z_][A-Za-z0-9_]*\).*/\1/p')" - if [ -z "${COLS}" ]; then - no "${TABLE} 的建表块里没解析出任何列" - else - BADCOLS="" - for c in ${COLS}; do - case "${c}" in - f_*) ;; - *) BADCOLS="${BADCOLS} ${c}" ;; - esac - done - if [ -n "${BADCOLS}" ]; then - no "列名不是 f_ 前缀:${BADCOLS}" - else - ok "全部列名都是 f_ 前缀($(printf '%s\n' "${COLS}" | wc -l | tr -d ' ') 列)" - fi - fi - if printf '%s\n' "${BLOCK}" | grep -q "f_id VARCHAR(50)"; then - ok "主键 f_id VARCHAR(50)(36 位 UUID 装得下)" - else - no "主键必须是 f_id VARCHAR(50)(不要写成 32,否则 36 位 UUID 装不下)" - fi - fi - - hdr "[${ENT}] 软删契约:list 带 f_delete_mark = 0 + remove 走软删(不是物理 DELETE)" - if grep -q "WHERE f_delete_mark = 0" "$CRUD" 2>/dev/null; then - ok "list 查询带 f_delete_mark = 0" - else - no "list 查询缺 f_delete_mark = 0 → 软删数据会显示" - fi - if grep -q "SET f_delete_mark = 1" "$CRUD" 2>/dev/null; then - ok "remove 置 f_delete_mark = 1(软删)" - else - no "remove 没软删(应是 UPDATE f_delete_mark=1,非物理 DELETE)" - fi -done - -# -------- 全局红线(与具体模块无关,但一样会让闸门失真)-------- -# -# 🔴 **面 A / 面 B 的判别头是 `Vue-Version: 3`**(见 JNPF_COMPAT_SURFACE.md §2.2): -# 官方 JNPF 前端**必带** `Jnpf-Origin: pc` / `App-Code` / `Vue-Version: 3` 三个头, -# 而本仓前端**只带前两个**(`App-Code: sswflow` + `Jnpf-Origin: pc`,与官方同款) -# ⇒ 三个头里**只有 `Vue-Version` 是本仓前端唯一不发的** ⇒ 判别只能用它。 -# 本仓前端一旦开始发 `Vue-Version` ⇒ 面 A 的请求会被误判成面 B ⇒ 契约整体错位。 -hdr "[全局] 面 A/面 B 判别头:前端**禁发** Vue-Version" -if grep -q "Vue-Version" "$FE/src/api/request.ts" 2>/dev/null; then - no "前端 request.ts 发了 Vue-Version 头 ⇒ 面 A 请求会被误判成面 B" -else - ok "前端 request.ts 未发 Vue-Version(面 A/面 B 判别成立)" -fi - -hdr "[全局] 面 B 尺子必须带判别头 Vue-Version: 3" -if grep -q "Vue-Version: 3" "$ROOT/scripts/perm-smoke-jnpf.sh" 2>/dev/null; then - ok "perm-smoke-jnpf.sh 带了 Vue-Version: 3" -else - no "perm-smoke-jnpf.sh 缺 Vue-Version: 3 ⇒ 面 B 请求不会被识别成面 B" -fi - -# -------- 尺子自证:跑出来的条数必须等于契约里登记的条数 -------- -# -# 🔴 **为什么要有这一条**:尺子自己**知道**自己断言了几条(PASS+FAIL)。 -# 如果哪天有人删掉了几条断言、或者某个分支提前 return 了,尺子照样「全绿」—— -# 变弱的尺子比没有尺子更危险。⇒ 条数由**契约**钉死,对不上 ⇒ 失败。 -# -# 🔴 只在**全量跑**(无参)时对账;单模块跑的条数本来就不是全量条数。 -CE_EXP_ASSERTIONS="$(row_field "${CE_RULER_ROWS}" "check-module.sh" assertions)" -if [ "$#" -eq 0 ] && [ -n "${CE_EXP_ASSERTIONS}" ]; then - CE_ACT_ASSERTIONS=$((PASS + FAIL)) - if [ "${CE_ACT_ASSERTIONS}" -eq "${CE_EXP_ASSERTIONS}" ]; then - # 🔴 自证**不计入** PASS/FAIL(它是元断言,不是业务断言)⇒ 契约里登记的条数 - # 永远是「业务断言数」,与文档里说的「N 条」是同一个数。 - echo " ✅ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言 = 契约登记的 ${CE_EXP_ASSERTIONS} 条" - else - echo " ❌ 尺子自证:本尺子跑了 ${CE_ACT_ASSERTIONS} 条断言,契约登记 ${CE_EXP_ASSERTIONS} 条 ⇒ 尺子被改弱了(少了/多了断言)" - FAIL=$((FAIL + 1)) - fi -fi - -# -------- 总结 -------- -echo -echo "── 总结 ──" -echo "Modules: ${TARGETS[*]}" -echo "PASS=$PASS FAIL=$FAIL" -if [ "$FAIL" -eq 0 ]; then - echo "全 ✅ 可以跑 perm-smoke 了" -else - echo "有 ❌,请按上面修复后再跑 perm-smoke" -fi - -exit $([ "$FAIL" -eq 0 ] && echo 0 || echo 1) diff --git a/scripts/check-scaffold.py b/scripts/check-scaffold.py new file mode 100755 index 0000000..c8303c2 --- /dev/null +++ b/scripts/check-scaffold.py @@ -0,0 +1,374 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""check-scaffold —— 本仓「只是业务仓」的静态判据。 + +🔴 **为什么需要它**(2026-11-04 改造后): + 平台实现已经搬到**已发布的 `sspf` 包**。如果没人钉住,最常见的退化是 + 「平台某段代码被顺手抄回业务仓」—— 抄回来的那一刻两份实现就开始分叉, + 而且**不会报错**:抄来的那份能编译、能跑,只是从此升级平台升不动了。 + + 所以本仓的判据不是「平台对不对」(那在平台仓),而是: + **本仓只准有业务**。 + +| # | 判据 | 违反的典型表现 | +|---|---|---| +| SC1 | 没有平台实现目录(`platform/` / `routes.rs` / `crates/` / `db/schema.sql`) | 把平台源码抄回来 | +| SC2 | 没有 `base_*` 建表语句 | 业务包/应用自建平台表 | +| SC3 | 应用 crate 只依赖 `sspf` 门面 | 直接依赖 `sspf-core` / `pglite-rs` 等内部件 | +| SC4 | 每个业务包只依赖 `sspf`,且目录齐全 | 包里去连库 / 缺 `pack.toml` | +| SC5 | `sspf` 只从 workspace 的 git tag 来(成员不另写来源) | 有人偷偷改成 `path = "../ssw-platform"` | +| SC6 | 生成物与 `packs/*` 不漂移 | 加包没跑 `pack-sync.py` | + +用法: + python3 scripts/check-scaffold.py # 主跑(SC1–SC6) + python3 scripts/check-scaffold.py --self-test # 反自证:每条尺子造一个违规,必须红 + +退出码:0 = 全绿 / 1 = 有判据红 / 2 = 前置错误 +""" + +import os +import shutil +import subprocess +import sys +import tempfile +import tomllib + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(HERE) + + +# ---------------------------------------------------------------- 判据 + + +def sc1_no_vendored_platform(root): + """本仓不得出现平台实现的目录 / 文件。""" + forbidden = [ + "src/backend/src/platform", + "src/backend/src/routes.rs", + "src/backend/src/bootstrap.rs", + "src/backend/db/schema.sql", + "crates", + ] + hits = [p for p in forbidden if os.path.exists(os.path.join(root, p))] + if hits: + return False, "本仓出现平台实现:" + ", ".join(hits) + "(平台在 `sspf` 包里)" + return True, "没有 platform/ / routes.rs / crates/ / db/schema.sql" + + +def _iter_sources(root): + for dirpath, dirnames, filenames in os.walk(root): + dirnames[:] = [ + d + for d in dirnames + if d + not in ( + ".git", + "target", + "node_modules", + "dist", + ".run", + ".logs", + ".tmp", + "__pycache__", + # 🔴 `docs/` 是**说明实物**(平台 DDL 的参考副本,给人读的), + # 不是会被执行的建表语句 —— 判据只看业务代码 / 业务 DDL。 + "docs", + ) + ] + for fn in filenames: + if fn.endswith((".rs", ".sql")): + yield os.path.join(dirpath, fn) + + +def sc2_no_base_tables(root): + """业务侧不得建 `base_*` 平台表(DDL 归平台包管)。""" + hits = [] + for path in _iter_sources(root): + try: + with open(path, encoding="utf-8", errors="ignore") as f: + text = f.read().lower() + except OSError: + continue + # 只看「建表」语境:CREATE TABLE [IF NOT EXISTS] base_xxx + idx = 0 + while True: + i = text.find("create table", idx) + if i < 0: + break + tail = text[i : i + 120] + if "base_" in tail: + hits.append(os.path.relpath(path, root)) + break + idx = i + 1 + if hits: + return False, "出现 base_* 建表语句:" + ", ".join(sorted(set(hits))) + return True, "业务侧没有 base_* 建表语句" + + +def _deps(toml_path): + with open(toml_path, "rb") as f: + data = tomllib.load(f) + return data.get("dependencies", {}) or {} + + +def sc3_app_only_needs_facade(root): + """应用 crate 只准依赖门面 `sspf`(+ 纯业务/框架件)。""" + path = os.path.join(root, "src/backend/Cargo.toml") + if not os.path.isfile(path): + return False, "找不到 src/backend/Cargo.toml" + + deps = _deps(path) + # 🔴 `sspf-pack-*` 是**业务包**(本仓自己的东西),不是平台内部件; + # 真正不许出现的是平台拆出来的那些 crate 与「被门面收编」的基础件。 + bad = [ + k + for k in deps + if (k.startswith("sspf-") and not k.startswith("sspf-pack-")) + or k in ("ssw-platform", "pglite-rs", "aes", "ecb", "md-5") + ] + if "sspf" not in deps: + return False, "应用 crate 没依赖 `sspf`(平台从哪来?)" + if bad: + return False, "应用 crate 直接依赖了平台内部件/被门面收编的件:" + ", ".join(sorted(bad)) + return True, "应用 crate 只依赖 `sspf` 门面(+ axum/tokio + 业务包)" + + +def sc4_packs_are_thin(root): + """每个业务包只依赖 `sspf`,且四件套齐全。""" + packs_dir = os.path.join(root, "packs") + if not os.path.isdir(packs_dir): + return False, "没有 packs/(示例业务包在哪?)" + + apps = sorted( + d for d in os.listdir(packs_dir) if os.path.isdir(os.path.join(packs_dir, d)) + ) + if not apps: + return False, "packs/ 下没有任何包" + + problems = [] + for app in apps: + base = os.path.join(packs_dir, app) + for rel in ("Cargo.toml", "pack.toml", "src/lib.rs", "schema/001_init.sql"): + if not os.path.isfile(os.path.join(base, rel)): + problems.append(f"packs/{app} 缺 {rel}") + + cargo = os.path.join(base, "Cargo.toml") + if os.path.isfile(cargo): + deps = _deps(cargo) + extra = [k for k in deps if k != "sspf"] + if "sspf" not in deps: + problems.append(f"packs/{app} 没依赖 `sspf`") + if extra: + problems.append(f"packs/{app} 多了依赖:{', '.join(sorted(extra))}") + + if problems: + return False, ";".join(problems) + return True, f"{len(apps)} 个包都只依赖 `sspf`,目录齐全" + + +def sc5_sspf_comes_from_a_tag(root): + """`sspf` 必须从 workspace 的 **git tag** 来,成员不许另写来源。""" + ws = os.path.join(root, "Cargo.toml") + with open(ws, "rb") as f: + data = tomllib.load(f) + dep = (data.get("workspace", {}).get("dependencies", {}) or {}).get("sspf") + if dep is None: + return False, "workspace.dependencies 里没有 `sspf`" + if isinstance(dep, str): + return False, "`sspf` 写成版本号(应锁 git tag,否则本地与 CI 拿到的不是同一份)" + if "git" not in dep or "tag" not in dep: + return False, "`sspf` 必须同时写 `git` 与 `tag`(现在是 %r)" % (dep,) + + # 成员不许另写来源 + offenders = [] + for member in ("src/backend/Cargo.toml",): + path = os.path.join(root, member) + if os.path.isfile(path): + d = _deps(path).get("sspf") + if isinstance(d, dict) and ("git" in d or "path" in d or "version" in d): + offenders.append(member) + if offenders: + return False, "成员自己写了 `sspf` 来源(应 `{ workspace = true }`):" + ", ".join(offenders) + return True, f"`sspf` 锁 git tag `{dep.get('tag')}`" + + +def sc6_generated_files_in_sync(root): + """生成物与 `packs/*` 不漂移(复用 pack-sync 的 --check)。""" + script = os.path.join(HERE, "pack-sync.py") + env = dict(os.environ, PACK_SYNC_ROOT=os.path.abspath(root)) + proc = subprocess.run( + [sys.executable, script, "--check"], + capture_output=True, + text=True, + cwd=root, + env=env, + ) + out = (proc.stdout + proc.stderr).strip().splitlines() + detail = out[-1] if out else "(无输出)" + return proc.returncode == 0, detail + + +CHECKS = [ + ("SC1", "本仓没有平台实现", sc1_no_vendored_platform), + ("SC2", "业务侧不建 base_* 表", sc2_no_base_tables), + ("SC3", "应用只依赖门面 sspf", sc3_app_only_needs_facade), + ("SC4", "业务包只依赖 sspf", sc4_packs_are_thin), + ("SC5", "sspf 锁 git tag", sc5_sspf_comes_from_a_tag), + ("SC6", "生成物无漂移", sc6_generated_files_in_sync), +] + + +# ---------------------------------------------------------------- 主跑 + + +def run(root, label=""): + ok_n = 0 + for code, name, fn in CHECKS: + passed, detail = fn(root) + if passed: + ok_n += 1 + print(f" ✅ {code} {name} —— {detail}") + else: + print(f" ❌ {code} {name} —— {detail}") + print(f"── {label}:PASS={ok_n} FAIL={len(CHECKS) - ok_n}") + return ok_n == len(CHECKS) + + +# ---------------------------------------------------------------- 反自证 + + +def _mk(root, rel, content=""): + path = os.path.join(root, rel) + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", encoding="utf-8") as f: + f.write(content) + + +def _base_tree(root): + """造一棵**最小合法**的树(六条判据都绿),再逐条注入违规。""" + _mk( + root, + "Cargo.toml", + '[workspace]\nmembers = ["src/backend", "packs/demo"]\n' + '[workspace.dependencies]\nsspf = { git = "http://x/y.git", tag = "v0.4.0" }\n', + ) + _mk( + root, + "src/backend/Cargo.toml", + '[package]\nname = "app"\nversion = "0.0.0"\n[dependencies]\nsspf = { workspace = true }\n', + ) + _mk(root, "src/backend/src/lib.rs", "// app\n") + _mk( + root, + "packs/demo/Cargo.toml", + '[package]\nname = "sspf-pack-demo"\nversion = "0.0.0"\n[dependencies]\nsspf = { workspace = true }\n', + ) + _mk(root, "packs/demo/pack.toml", '[pack]\napp_code = "demo"\n') + _mk(root, "packs/demo/src/lib.rs", "// pack\n") + _mk(root, "packs/demo/schema/001_init.sql", "CREATE TABLE IF NOT EXISTS demo_item (f_id text);\n") + # 生成物:直接让 pack-sync 写一遍(它认 packs/* 与 modules/*) + _mk( + root, + "src/backend/src/modules/mod.rs", + "// >>>GEN:MODS\n// <<>>GEN:SPECS\n// <<>>GEN:ROUTES\n// <<>>GEN:MENUS\n// <<>>GEN:ROUTER\n// <<>>GEN:PACKS\n// <<>>GEN:MANIFESTS\n// <<>>GEN:PACK_DEPS\n# <</`)+ 它的面 A 适配器。 + +🔴 **加业务只碰两处**:业务包(表 / 列 / 菜单 / 面 B 路由)与面 A 适配器。 + 其余(`packs_gen.rs`、`modules/mod.rs` 的五个段、应用 `Cargo.toml` 的包依赖) + 全部由 `pack-sync.py` 生成 ⇒ 手抄漏一处就静默 404 的情况**在机制上不存在**。 + +用法: + python3 scripts/new-pack.py --name "中文名" \\ + [--columns "title:VARCHAR(255),price:NUMERIC(12,2)"] [--sort 20] + +例: + python3 scripts/new-pack.py blog Post --name "文章" --columns "title:VARCHAR(255),body:TEXT" + ⇒ packs/blog/{Cargo.toml,pack.toml,schema/001_init.sql,src/lib.rs} + ⇒ src/backend/src/modules/blog.rs + ⇒ 自动跑 pack-sync.py 补齐生成段 + +生成后:`cargo check` + `bash scripts/verify.sh`(面 A / 面 B 两把尺子会打到新端点)。 + +退出码:0 = 成功 / 2 = 用法错或目标已存在 +""" + +import os +import re +import subprocess +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.environ.get("PACK_SYNC_ROOT") or os.path.dirname(HERE) + + +def camel_to_snake(s): + s = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", s) + return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s).lower() + + +def camel_to_kebab(s): + return camel_to_snake(s).replace("_", "-") + + +def lower_camel(s): + return s[0].lower() + s[1:] + + +def split_columns(spec): + """按逗号切列定义,但**不切括号里的逗号**(`NUMERIC(12,2)`)。""" + parts, buf, depth = [], "", 0 + for ch in spec: + if ch == "(": + depth += 1 + elif ch == ")": + depth -= 1 + if ch == "," and depth == 0: + parts.append(buf) + buf = "" + else: + buf += ch + if buf.strip(): + parts.append(buf) + return parts + + +def parse_columns(spec): + """`"title:VARCHAR(255),price:NUMERIC(12,2)"` ⇒ [(name, sql_type, numeric)]。""" + cols = [] + if not spec: + return cols + for item in split_columns(spec): + item = item.strip() + if not item: + continue + if ":" not in item: + raise SystemExit(f"列定义缺类型:{item!r}(应该是 `名字:SQL类型`)") + name, sql_type = item.split(":", 1) + name = name.strip() + if not re.fullmatch(r"[a-z][a-z0-9_]*", name): + raise SystemExit(f"列名只收小写字母/数字/下划线:{name!r}") + sql_type = sql_type.strip() + numeric = sql_type.upper().startswith(("NUMERIC", "DECIMAL", "REAL", "DOUBLE")) + cols.append((name, sql_type, numeric)) + return cols + + +def pack_toml(app, entity, name, table, columns): + return f"""# 业务包清单 —— `{app}`({name})。 +# 🔴 本文件不是给 cargo 读的,是给装载器(`sspf::load_static` 的 JSON 快照对账) +# 与导出工具读的。改了它 ⇒ 必须跑 `python3 scripts/pack-sync.py`。 + +[pack] +app_code = "{app}" +name = "{name}" +version = "1.0.0" +kernel = ">=0.4,<0.5" # 契约版本区间(不是 cargo 版本) +migratable = true + +[pack.compat] +baseline = "react-demo" # 对齐基准 +frontend = "vue3" # 前端族(决定表单 JSON 方言) +tenant = false # 本期单租户(列仍带 f_tenant_id,见 DDL 注释) + +[[pack.tables]] +name = "{table}" +ddl = "schema/001_init.sql" +baseline_table = "{table}" + +[pack.metadata] +forms = [] +models = [] +menus = [] +flows = [] + +[pack.build] +kind = "none" +""" + + +def pack_cargo(app): + return f"""[package] +name = "sspf-pack-{app}" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 业务包只允许依赖平台门面 `sspf`。 +# 出现 axum / tokio / pglite ⇒ `scripts/check-scaffold.sh` 直接红 +# ⇒ 「整目录可搬走」的技术保证。 +[dependencies] +sspf = {{ workspace = true }} +""" + + +def ddl_sql(app, entity, table, columns): + col_lines = "".join(f" f_{n} {t},\n" for n, t, _ in columns) + return f"""-- {table} —— {entity} 的业务表(业务包自带的 DDL)。 +-- +-- 🔴 **DDL 跟着包走**:本文件由 `packs/{app}/src/lib.rs` 用 `include_str!` +-- 编译进二进制 ⇒ 启动时按包顺序幂等执行(不再手抄进平台 schema)。 +-- 🔴 **只许建本包自己的表**,**不许建 `base_*`**(装载器会拦)。 +-- 🔴 `f_tenant_id` 是包 DDL 的硬要求(本期单租户,值恒 `'0'`); +-- spec 的列清单**不含**它 ⇒ 面 A / 面 B 的 JSON 形状不受影响。 + +CREATE TABLE IF NOT EXISTS {table} ( + f_id VARCHAR(50) NOT NULL, +{col_lines} f_creator_user_id VARCHAR(50), + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_mark INTEGER DEFAULT 0, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); +""" + + +def pack_lib(app, entity, name, table, columns, sort): + up = camel_to_snake(entity).upper() # DATA_RESOURCE + lc = lower_camel(entity) # dataResource + cols_rs = [] + for n, _t, numeric in columns: + cols_rs.append( + f""" ColumnSpec {{ + column: "f_{n}", + json_key: "{lower_camel(n)}", + default: None, + numeric: {"true" if numeric else "false"}, + }},""" + ) + cols_rs.append( + """ ColumnSpec { + column: "f_creator_user_id", + json_key: "creatorUserId", + default: None, + numeric: false, + }, + ColumnSpec { + column: "f_creator_time", + json_key: "creatorTime", + default: None, + numeric: false, + },""" + ) + columns_block = "\n".join(cols_rs) + numeric_list = ", ".join(f'"f_{n}"' for n, _t, num in columns if num) + + return f'''//! {app} —— {name}业务包。 +//! +//! 🔴 **这里是业务真源**:表 + 列 + 菜单 + 面 B 路由都在这个目录里。 +//! 面 A 适配器在同仓 `src/backend/src/modules/{app}.rs`(只做转发,不重写 spec)。 +//! 🔴 **依赖纪律**:本包只依赖 `sspf` 门面;出现 axum / tokio / pglite 会被 +//! `scripts/check-scaffold.sh` 判红 —— 这是「整目录可搬走」的技术保证。 + +use sspf::{{ + BusinessPack, ColumnSpec, EntitySpec, HttpMethod, Manifest, MenuSpec, PackRoute, RouteAction, + RouteGuard, +}}; + +/// 本包自带的 DDL(编译进二进制 ⇒ 包目录可整目录搬走)。 +pub const {up}_DDL: &str = include_str!("../schema/001_init.sql"); + +/// 包的统一 DDL 出口(`表名 → DDL 文本`)—— 内核只认这一种写法。 +pub const DDLS: &[(&str, &str)] = &[("{table}", {up}_DDL)]; + +/// `{table}` 的列清单(**顺序 = 响应 JSON 的键序**)。 +const {up}_COLUMNS: &[ColumnSpec] = &[ +{columns_block} +]; + +/// 实体 spec(面 A / 面 B 共用这一份)。 +pub const {up}_SPEC: EntitySpec = EntitySpec {{ + app_code: "{app}", + entity: "{entity}", + table: "{table}", + // 🔴 `module_key` 必须 == 菜单 `url_address` == 前端 Route path(三处一字不差)。 + module_key: Some("{app}/{entity}"), + columns: {up}_COLUMNS, + numeric_columns: &[{numeric_list}], + creator_fixed: None, +}}; + +/// 本包的内置菜单(`url_address` 与 spec 的 `module_key` 一字不差)。 +pub const {up}_MENU: MenuSpec = MenuSpec {{ + id: "m_{app}", + full_name: "{name}", + en_code: "permission.{app}.{lc}", + url_address: "{app}/{entity}", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: {sort}, + system_en_code: "mainSystem", +}}; + +/// 包清单(与 `pack.toml` 的 `[pack]` 段一致)。 +const MANIFEST: Manifest = Manifest {{ + app_code: "{app}", + name: "{name}", + version: "1.0.0", + kernel_req: ">=0.4,<0.5", + migratable: true, +}}; + +// ---------------------------------------------------------------- 面 B 路由 +// +// 🔴 **官方 RESTful 形状**:`GET/POST /api/{app}/{entity}` + `DELETE .../{{id}}` +// —— 不是面 A 的 `/api/ssw/...`。面 A 在 `modules/{app}.rs`。 + +/// `GET /api/{app}/{entity}` —— 列表。 +pub const {up}_LIST_ROUTE: PackRoute = PackRoute {{ + path: "/api/{app}/{entity}", + method: HttpMethod::Get, + entity: "{entity}", + action: RouteAction::List, + guard: RouteGuard::Login, +}}; + +/// `POST /api/{app}/{entity}` —— 新建 / 更新(body 带 `id` 就是更新)。 +pub const {up}_SAVE_ROUTE: PackRoute = PackRoute {{ + path: "/api/{app}/{entity}", + method: HttpMethod::Post, + entity: "{entity}", + action: RouteAction::Save, + guard: RouteGuard::Login, +}}; + +/// `DELETE /api/{app}/{entity}/{{id}}` —— 软删。 +pub const {up}_DELETE_ROUTE: PackRoute = PackRoute {{ + path: "/api/{app}/{entity}/{{id}}", + method: HttpMethod::Delete, + entity: "{entity}", + action: RouteAction::Delete, + guard: RouteGuard::Login, +}}; + +/// 本包声明的全部路由(每条实体恰好 3 条)。 +pub const {up}_ROUTES: &[PackRoute] = &[{up}_LIST_ROUTE, {up}_SAVE_ROUTE, {up}_DELETE_ROUTE]; + +/// 业务包本体(类型名固定 `Pack` —— `packs_gen.rs` 按 `sspf_pack_::Pack` 拼)。 +pub struct Pack; + +impl BusinessPack for Pack {{ + fn manifest(&self) -> &'static Manifest {{ + &MANIFEST + }} + + fn entities(&self) -> &'static [EntitySpec] {{ + &[{up}_SPEC] + }} + + fn menus(&self) -> &'static [MenuSpec] {{ + &[{up}_MENU] + }} + + fn routes(&self) -> &'static [PackRoute] {{ + {up}_ROUTES + }} +}} +''' + + +def module_rs(app, entity, name): + up = camel_to_snake(entity).upper() + snake = camel_to_snake(entity) + svc = camel_to_kebab(entity) + return f'''//! {app} —— 面 A 适配器:{entity}(物理表 `{app}_{snake}`)。 +//! +//! 🔴 **spec 的家在 `packs/{app}/src/lib.rs`**(业务包),本文件只做 `pub use` 转发 +//! ⇒ **spec 只有一份**(两份拷贝迟早分叉)。 +//! 🔴 **面 A 与面 B 各住一处**: +//! - 本文件 = 面 A(`/api/ssw/{app}/{entity}/…`,本仓自造约定,前端在用); +//! - 业务包 = 面 B(`/api/{app}/{entity}`,官方 JNPF 形状)。 + +use axum::body::Bytes; +use axum::extract::{{RawQuery, State}}; +use axum::http::HeaderMap; +use axum::routing::{{delete, get, post}}; +use axum::{{Json, Router}}; + +use sspf::crud::{{handle_delete, handle_list, handle_save}}; +use sspf::envelope::ActionResult; +use sspf::AppState; + +// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。 +pub use sspf_pack_{app}::{up}_MENU; +pub use sspf_pack_{app}::{up}_SPEC; + +/// 本模块的 3 条路由(面 A)。 +pub const ROUTES: [&str; 3] = [ + "/api/ssw/{app}/{entity}/List", + "/api/ssw/{app}/{entity}/Save", + "/api/ssw/{app}/{entity}/Delete", +]; + +/// `GET /api/ssw/{app}/{entity}/List`。 +pub async fn {snake}_list(State(state): State, headers: HeaderMap) -> Json {{ + handle_list(&state, &headers, &{up}_SPEC).await +}} + +/// `POST /api/ssw/{app}/{entity}/Save`。 +pub async fn {snake}_save( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json {{ + handle_save(&state, &headers, &{up}_SPEC, &body).await +}} + +/// `DELETE /api/ssw/{app}/{entity}/Delete?id=`。 +pub async fn {snake}_delete( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json {{ + handle_delete(&state, &headers, &{up}_SPEC, &raw).await +}} + +/// 本模块的路由(面 A,`Router::merge` 进平台装配链)。 +/// +/// 🔴 路径写字面量(不用下标):契约与静态扫描都是**文本对账**,写下标会判「登记了、代码里没有」。 +pub fn router() -> Router {{ + Router::new() + .route("/api/ssw/{app}/{entity}/List", get({snake}_list)) + .route("/api/ssw/{app}/{entity}/Save", post({snake}_save)) + .route("/api/ssw/{app}/{entity}/Delete", delete({snake}_delete)) +}} +''' + + +def main(argv): + pos = [a for a in argv if not a.startswith("--")] + opts = {} + i = 0 + while i < len(argv): + if argv[i].startswith("--"): + key = argv[i][2:] + val = argv[i + 1] if i + 1 < len(argv) else "" + opts[key] = val + i += 2 + else: + i += 1 + + if len(pos) < 2 or "--help" in opts or "-h" in argv: + print(__doc__) + return 2 + + app, entity = pos[0], pos[1] + if not re.fullmatch(r"[a-z][a-z0-9_]*", app): + print(f"❌ app 只收小写字母/数字/下划线:{app!r}") + return 2 + if not re.fullmatch(r"[A-Z][A-Za-z0-9]*", entity): + print(f"❌ Entity 必须是 UpperCamelCase:{entity!r}") + return 2 + + name = opts.get("name") or entity + sort = int(opts.get("sort") or 20) + columns = parse_columns(opts.get("columns", "")) + + pack_dir = os.path.join(ROOT, "packs", app) + mod_file = os.path.join(ROOT, "src/backend/src/modules", f"{app}.rs") + if os.path.exists(pack_dir) or os.path.exists(mod_file): + print(f"❌ 目标已存在:{pack_dir} 或 {mod_file}(换个 app 名,或先删掉)") + return 2 + + table = f"{app}_{camel_to_snake(entity)}" + + os.makedirs(os.path.join(pack_dir, "schema"), exist_ok=True) + os.makedirs(os.path.join(pack_dir, "src"), exist_ok=True) + + def write(rel, content): + path = os.path.join(pack_dir, rel) + with open(path, "w", encoding="utf-8") as f: + f.write(content) + + write("Cargo.toml", pack_cargo(app)) + write("pack.toml", pack_toml(app, entity, name, table, columns)) + write("schema/001_init.sql", ddl_sql(app, entity, table, columns)) + write("src/lib.rs", pack_lib(app, entity, name, table, columns, sort)) + with open(mod_file, "w", encoding="utf-8") as f: + f.write(module_rs(app, entity, name)) + + print(f"✅ 建包:packs/{app}/(表 {table})+ modules/{app}.rs") + + sync = subprocess.run( + [sys.executable, os.path.join(HERE, "pack-sync.py")], + cwd=ROOT, + env=dict(os.environ, PACK_SYNC_ROOT=ROOT), + capture_output=True, + text=True, + ) + print(sync.stdout.strip() or sync.stderr.strip()) + if sync.returncode != 0: + print("❌ pack-sync 失败 —— 生成段没补上,先修上面的错") + return sync.returncode + + print("下一步:`cargo check` 然后 `bash scripts/verify.sh`") + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/scripts/new-pack.sh b/scripts/new-pack.sh new file mode 100755 index 0000000..5cc38c1 --- /dev/null +++ b/scripts/new-pack.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +# new-pack.sh —— 造一个业务包 + 面 A 适配器(薄封装,实现在 new-pack.py) +# +# 用法: +# bash scripts/new-pack.sh --name "中文名" \ +# [--columns "title:VARCHAR(255),price:NUMERIC(12,2)"] [--sort 20] +# +# 它会建 `packs//`(真源)+ `src/backend/src/modules/.rs`(面 A), +# 然后跑 `pack-sync.py` 补齐 `packs_gen.rs` / `modules/mod.rs` / `Cargo.toml` 的生成段。 +set -u +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +exec python3 "${ROOT}/scripts/new-pack.py" "$@" diff --git a/scripts/pack-sync.py b/scripts/pack-sync.py new file mode 100755 index 0000000..c7a31ec --- /dev/null +++ b/scripts/pack-sync.py @@ -0,0 +1,361 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""pack-sync —— 把业务包声明同步到所有「派生位置」。 + +🔴 **为什么存在**:加一个业务包要改四处**派生位置**,其中两处漏了**不报错**: + +| # | 派生位置 | 内容 | 漏了会怎样 | +|---|---|---|---| +| ① | `src/backend/src/packs_gen.rs` 的 `>>>GEN:PACKS` | `load_static` 调用 | 面 B 端点**静默 404** | +| ② | `src/backend/src/packs_gen.rs` 的 `>>>GEN:MANIFESTS` | `pack.toml` 的 JSON 快照 | 装载失败 / 清单与真源不一致 | +| ③ | `src/backend/src/modules/mod.rs` 五个生成段 | `pub mod` / `ALL_SPECS` / `ALL_ROUTES` / `ALL_MENUS` / `router()` | 面 A **静默 404** + 菜单不种 ⇒ 守卫查不到 | +| ④ | `src/backend/Cargo.toml` 的 `# >>>GEN:PACK_DEPS` | 每个包的 path 依赖 | 编译报错(响亮) | + +⇒ 全部由本脚本从 **`packs/*/pack.toml` + `modules/*.rs`** 生成; + `--check` 在「改了包没跑生成」时**红**,不要让漂移活到运行时。 + +🔴 **真源**: + - 表 DDL / 列 / 菜单 / 面 B 路由 ⇒ `packs//`(业务包,只依赖 `sspf` 门面) + - 面 A 适配器 / spec 转发 ⇒ `src/backend/src/modules/.rs` + +用法: + python3 scripts/pack-sync.py # 同步(幂等) + python3 scripts/pack-sync.py --check # 只检查(不写)⇒ 有漂移就退出 1 + python3 scripts/pack-sync.py --dry-run # 打印将要写入的内容 + +退出码:0 = 成功 / 1 = --check 发现漂移 / 2 = 用法错或前置错误 +""" + +import json +import os +import re +import sys +import tomllib + +HERE = os.path.dirname(os.path.abspath(__file__)) +# 🔴 `PACK_SYNC_ROOT` 只给**反自证**用(`check-scaffold.py --self-test` 在临时树里跑)—— +# 缺了它,「生成物漂移」这条尺子就只能检查真实仓库 ⇒ 自证会假绿。 +ROOT = os.environ.get("PACK_SYNC_ROOT") or os.path.dirname(HERE) + +PACKS_DIR = os.path.join(ROOT, "packs") +MODULES_DIR = os.path.join(ROOT, "src/backend/src/modules") +PACKS_GEN = os.path.join(ROOT, "src/backend/src/packs_gen.rs") +MOD_RS = os.path.join(MODULES_DIR, "mod.rs") +APP_CARGO = os.path.join(ROOT, "src/backend/Cargo.toml") + + +class SyncError(Exception): + """前置错误(不是漂移)⇒ 退出码 2。""" + + +# ---------------------------------------------------------------- 读取真源 + + +def read_packs(): + """`packs/*/pack.toml` ⇒ {app: manifest dict}(按 app 字典序)。""" + if not os.path.isdir(PACKS_DIR): + raise SyncError(f"没有 {PACKS_DIR}(业务包目录)") + + out = {} + for name in sorted(os.listdir(PACKS_DIR)): + path = os.path.join(PACKS_DIR, name, "pack.toml") + if not os.path.isfile(path): + continue + with open(path, "rb") as f: + data = tomllib.load(f) + pack = data.get("pack") + if not pack: + raise SyncError(f"{path} 缺 [pack] 段") + app = pack.get("app_code") + if app != name: + raise SyncError(f"{path} 的 app_code={app!r} 与目录名 {name!r} 不一致") + out[app] = pack + if not out: + raise SyncError(f"{PACKS_DIR} 下没有任何包(pack.toml)") + return out + + +MODULE_SPEC_RE = re.compile(r"pub use sspf_pack_[a-z0-9_]+::([A-Z0-9_]+_SPEC);") +MODULE_MENU_RE = re.compile(r"pub use sspf_pack_[a-z0-9_]+::([A-Z0-9_]+_MENU);") +MODULE_ROUTES_RE = re.compile(r"pub const ROUTES: \[&str; (\d+)\]") + + +def read_modules(): + """`modules/*.rs`(除 mod.rs)⇒ {app: {spec, menu, routes}}。""" + if not os.path.isdir(MODULES_DIR): + raise SyncError(f"没有 {MODULES_DIR}") + + out = {} + for fn in sorted(os.listdir(MODULES_DIR)): + if not fn.endswith(".rs") or fn == "mod.rs": + continue + app = fn[: -len(".rs")] + with open(os.path.join(MODULES_DIR, fn), encoding="utf-8") as f: + src = f.read() + + spec = MODULE_SPEC_RE.search(src) + if not spec: + raise SyncError( + f"modules/{fn} 里找不到 `pub use sspf_pack_{app}::_SPEC;`" + "(面 A 适配器必须转发包的 spec,不许自己重写一份)" + ) + menu = MODULE_MENU_RE.search(src) + routes = MODULE_ROUTES_RE.search(src) + if not routes: + raise SyncError(f"modules/{fn} 里找不到 `pub const ROUTES: [&str; N]`") + + out[app] = { + "spec": spec.group(1), + "menu": menu.group(1) if menu else None, + "routes": int(routes.group(1)), + } + + if not out: + raise SyncError(f"{MODULES_DIR} 下没有任何业务模块") + return out + + +def cross_check(packs, mods): + """包与适配器必须一一对应(两边各少一个都是错的)。""" + only_pack = sorted(set(packs) - set(mods)) + only_mod = sorted(set(mods) - set(packs)) + if only_pack: + raise SyncError( + "这些包没有面 A 适配器:" + + ", ".join(only_pack) + + "(跑 `bash scripts/new-pack.sh` 补齐,或删掉该包)" + ) + if only_mod: + raise SyncError( + "这些模块没有对应的包:" + + ", ".join(only_mod) + + "(业务真源在 `packs//`,模块只是适配器)" + ) + + +# ---------------------------------------------------------------- 渲染 + + +def gen_manifest_json(pack): + """`pack.toml` ⇒ 装载器认的 JSON 快照(只取内核需要的字段)。""" + tables = [ + { + "name": t["name"], + "ddl": t.get("ddl", ""), + "baseline_table": t.get("baseline_table", t["name"]), + } + for t in pack.get("tables", []) + ] + doc = { + "pack": { + "app_code": pack["app_code"], + "name": pack.get("name", pack["app_code"]), + "version": pack.get("version", "1.0.0"), + "kernel": pack.get("kernel", ""), + "migratable": bool(pack.get("migratable", True)), + "tables": tables, + } + } + return json.dumps(doc, ensure_ascii=False, indent=2) + + +def const_prefix(app): + return app.upper().replace("-", "_") + + +def gen_pack_calls(packs): + out = [] + for app in sorted(packs): + crate = "sspf-pack-" + app + out.append(f" // ---- {app} ----") + out.append(" regs.push(load_static(") + out.append(f' "{app}",') + out.append(f" {const_prefix(app)}_MANIFEST_JSON,") + out.append(f" Box::new({crate.replace('-', '_')}::Pack),") + out.append(f" {crate.replace('-', '_')}::DDLS,") + out.append(" kernel_version,") + out.append(" )?);") + out.append("") + return "\n".join(out).rstrip("\n") + + +def gen_manifests(packs): + out = [] + for app in sorted(packs): + out.append(f"/// `packs/{app}/pack.toml` 的编译期快照。") + out.append(f'const {const_prefix(app)}_MANIFEST_JSON: &str = r#"{gen_manifest_json(packs[app])}"#;') + out.append("") + return "\n".join(out).rstrip("\n") + + +def gen_mods(mods): + return "\n".join(f"pub mod {app};" for app in sorted(mods)) + + +def gen_specs(mods): + body = "\n".join(f" {app}::{mods[app]['spec']}," for app in sorted(mods)) + return ( + "/// 全部业务实体 spec。\n" + "///\n" + "/// 🔴 **本段由 `scripts/pack-sync.py` 生成** —— 加模块不用手改(见文件头)。\n" + "pub const ALL_SPECS: &[EntitySpec] = &[\n" + f"{body}\n" + "];" + ) + + +def gen_routes(mods): + lines = [] + for app in sorted(mods): + lines.extend(f" {app}::ROUTES[{i}]," for i in range(mods[app]["routes"])) + body = "\n".join(lines) + return ( + "/// **全部业务路由**(面 A:`/api/ssw/{appCode}/{Entity}/{动作}`,每模块 3 条)。\n" + "///\n" + "/// 🔴 **与 `ALL_SPECS` 同序**(同一份模块清单生成)⇒ 可以按 3 条一组配对。\n" + "pub const ALL_ROUTES: &[&str] = &[\n" + f"{body}\n" + "];" + ) + + +def gen_menus(mods): + lines = [] + for app in sorted(mods): + if mods[app]["menu"]: + lines.append(f" {app}::{mods[app]['menu']},") + body = "\n".join(lines) + return ( + "/// 全部业务内置菜单(**给人看的快照**)。\n" + "///\n" + "/// 🔴 真正种进库的是 `packs/*` 里 `BusinessPack::menus()` 的那一份\n" + "/// (`sspf::Platform::packs(reg)` 把 `PackRegistry.menus` 直接带进两段式种子)。\n" + "/// **不要再把本数组传给 `.menus()`** —— 同一份菜单给两次,种子 INSERT 会撞主键。\n" + "/// 这里留着是给测试 / 排障一个稳定的、不依赖装载流程的清单。\n" + "pub const ALL_MENUS: &[MenuSpec] = &[\n" + f"{body}\n" + "];" + ) + + +def gen_router(mods): + apps = sorted(mods) + body = f" {apps[0]}::router()" + for app in apps[1:]: + body += f"\n .merge({app}::router())" + return ( + "/// **全部业务模块的路由**(面 A,`Router::merge` 进平台装配链)。\n" + "///\n" + "/// 🔴 加业务模块 ⇒ **不用改这里**(本段由 `pack-sync.py` 生成)。\n" + "pub fn router() -> Router {\n" + f"{body}\n" + "}" + ) + + +def gen_pack_deps(packs): + return "\n".join( + f'sspf-pack-{app} = {{ path = "../../packs/{app}" }}' for app in sorted(packs) + ) + + +# ---------------------------------------------------------------- 写回 + + +def replace_region(text, begin, end, body, where): + """把 `begin`/`end` 标记**之间**的内容换成 body(标记本身保留)。""" + i = text.find(begin) + j = text.find(end) + if i < 0 or j < 0 or j < i: + raise SyncError(f"{where} 里找不到生成段标记 {begin} / {end}") + head = text[: i + len(begin)] + tail = text[j:] + return head + "\n" + body + "\n" + tail + + +def build_outputs(packs, mods): + with open(PACKS_GEN, encoding="utf-8") as f: + packs_gen = f.read() + with open(MOD_RS, encoding="utf-8") as f: + mod_rs = f.read() + with open(APP_CARGO, encoding="utf-8") as f: + app_cargo = f.read() + + new_packs_gen = replace_region( + packs_gen, + "// >>>GEN:PACKS", + "// <<>>GEN:MANIFESTS", + "// <<>>GEN:MODS", "// <<>>GEN:SPECS", "// <<>>GEN:ROUTES", "// <<>>GEN:MENUS", "// <<>>GEN:ROUTER", "// <<>>GEN:PACK_DEPS", "# <<>>GEN:PACK_DEPS +sspf-pack-asset = { path = "../../packs/asset" } +sspf-pack-books = { path = "../../packs/books" } +sspf-pack-demo = { path = "../../packs/demo" } +sspf-pack-shop = { path = "../../packs/shop" } +# <<.rs`:列清单 + `EntitySpec` + `*_MENU` + 3 个 handler + `router()`; -//! 2. 在 [`crate::modules::ALL_SPECS`] / [`crate::modules::ALL_MENUS`] 各加一条; -//! 3. 业务表 DDL 加进 `db/schema.sql`。 -//! ⇒ **平台层一个字都不用改**,本文件也不用改。 - -use crate::modules; -use crate::platform::db::{pglite, Db}; -use crate::platform::seed; - -/// 两段式种子的**第一段**(幂等,每次启动都跑)—— 平台层 + 业务层一起种。 -/// -/// 🔴 这是**应用与测试共用的唯一种子入口**(测试也调它 ⇒ 测试里的库 -/// 与真实运行时的库**逐字一致** ⇒ 冒烟测到的东西就是上线的东西)。 -/// -/// - `db`:库句柄。 -pub async fn ensure_base(db: &Db) -> Result<(), pglite::Error> { - seed::ensure_base(db, modules::all_menus()).await -} diff --git a/src/backend/src/lib.rs b/src/backend/src/lib.rs index 4b65a3c..28bc8c7 100644 --- a/src/backend/src/lib.rs +++ b/src/backend/src/lib.rs @@ -1,18 +1,25 @@ -//! ssw-jnpf-lite-rust —— JNPF 兼容契约的 Rust 实现(库入口)。 +//! ssw-jnpf-lite-rust —— 示例应用(**薄壳**)的库入口。 //! -//! 🔴 **两层结构**(对齐 `ssw-jnpf-lite-react` 的 `common`+`auth`+`sys` / `demo`+`shop`+`books`, -//! 以及官方 JNPF 的 `jnpf-common`+`jnpf-system` / `jnpf-admin`): +//! ## 本仓是什么(2026-11-04 改造后) //! -//! | 层 | 模块 | 职责 | 加业务模块时 | -//! |---|---|---|---| -//! | **平台层** | [`platform`] | 契约实现(信封 / cipher / 登录 / 权限 / `base_*` 管理 / 面 B / CRUD 引擎) | **不动** | -//! | **业务层** | [`modules`] | 业务实体 spec + 各自的 handler 与路由 | **只动这里** | +//! **平台不在本仓**:登录 / 权限 / 面 A·B / 低代码 / MCP / 177 张 `base_*` 表 +//! 全部来自**已发布的 `sspf` 包**(`Cargo.toml` 的 git tag)。 +//! 本仓是「**业务仓长什么样**」的样板: //! -//! 顶层三个文件:[`routes`](路由装配)、`main.rs`(启动装配)、本文件(模块清单)。 +//! | 位置 | 是什么 | 谁生成 | +//! |---|---|---| +//! | [`packs_gen`] | 业务包清单(装载 `packs/*`) | `scripts/pack-sync.py` | +//! | [`modules`] | 面 A 适配器 + 菜单快照 | `scripts/pack-sync.py`(生成段)+ 手写 handler | +//! | `main.rs` | 把上面两样交给 `sspf::Platform` | 手写 | +//! | `packs/*` | 业务真源:表 DDL + 列 + 菜单 + 面 B 路由 | 手写 / `scripts/new-pack.sh` | //! -//! 🔴 另加 [`bootstrap`] = **装配根**(唯一同时认识平台层与业务层的地方)。 +//! 🔴 **加一个业务模块只碰 `packs/` + `modules/`**:平台一个字都不用改 +//! (它根本不在本仓)。生成物由 `python3 scripts/pack-sync.py` 补齐, +//! `--check` 会在忘了跑的时候红。 +//! +//! 🔴 **不要在本仓写平台代码**:本仓出现 `platform/`、自研 CRUD 引擎、 +//! `base_*` 建表语句 ⇒ 就是「把平台源码抄进业务仓」——`scripts/check-scaffold.sh` +//! 会判红(判据是「本仓只准有业务」)。 -pub mod bootstrap; pub mod modules; -pub mod platform; -pub mod routes; +pub mod packs_gen; diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 4b84b72..1fc0f81 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -1,342 +1,106 @@ -//! ssw-jnpf-lite-rust 二进制入口 —— 启动装配(契约 §10)。 +//! ssw-jnpf-lite-rust 二进制入口 —— **薄装配**(约 100 行,全部逻辑在 `sspf` 里)。 //! -//! 装配顺序(契约 §10,逐字): -//! 1. [`resolve_project_dir`] —— 从可执行文件向上找锚点(`/src/backend/db/schema.sql` -//! **与** `/Cargo.toml`),**与 cwd 解耦**(后台启动时 cwd 会漂移); -//! 2. `Config::from_env(project_dir)`; -//! 3. **标识符白名单自检**(不过 ⇒ 打印人话 + `exit 1`),**放在开库之前**; -//! 4. `Db::open` / `Db::open_temp` ⇒ `ensure_schema()`; -//! 5. `bootstrap::ensure_base()` ⇒ `seed::first_seed()`(种子失败 ⇒ 打印人话 + `exit 1`); -//! 6. `routes::build_app(state)` —— **装配链的唯一权威**(顺序即 S25 的要害: -//! `build_router` → **404 兜底** → **405 / 413 改写中间件** → **catch-all 中间件** -//! → `with_state(state)`(**链尾**)); -//! 7. `TcpListener::bind` ⇒ 绑定失败**打印人话 + `exit 1`**(**不 panic**)。 +//! ## 这个文件只做三件事 //! -//! 🔴 **优雅停机**:`SIGTERM` / `SIGINT` ⇒ `with_graceful_shutdown` 收完在途请求 ⇒ -//! 优雅关闭嵌入式 PostgreSQL(不再被 `SIGKILL` 打断 ⇒ 数据目录不留 `postmaster.pid`)。 +//! 1. **解析命令行**(`--enc` / `--help`);无参数 ⇒ 起服务。 +//! 2. **定位项目根**([`resolve_project_dir`])—— 与 cwd 解耦,后台启动时 cwd 会漂。 +//! 3. **把业务交给平台**: //! -//! 🔴 本仓**刻意不同**于 react 版(那里是 try/catch + `logger.warn` 后**继续跑**): -//! 本仓是单二进制,启动期不变量破了就立刻退出 —— 服务要么正常起来,要么根本不起来。 +//! ```text +//! sspf::Platform::new() +//! .config(Config::from_env(项目根)) // 端口 / 数据目录 / 部署档位 +//! .packs(packs_gen::registry(..)?) // 业务包:DDL + 实体 + 菜单 + 面 B 路由 +//! .router(modules::router()) // 面 A 适配器(前端在用) +//! .static_dir(/src/frontend/dist) // SPA 深链回退 +//! .serve() +//! ``` +//! +//! 🔴 **装配顺序不在这里**:开库 / 平台 DDL / 业务 DDL / 种子 / 生产档守卫 / +//! 唯一 fallback,全部由 `sspf::platform::Platform` 的 `boot()` 定死 +//! (见该 crate 的注释)。业务仓**不许**自己排一遍 —— 排错一步就是静默故障。 +//! +//! 🔴 **没有 `.menus(...)`**:业务菜单在 `packs/*` 的 `BusinessPack::menus()` 里, +//! 由 `.packs(reg)` 一并带进种子。给两次会在种子里撞主键。 use std::path::PathBuf; -use std::sync::Arc; -use ssw_jnpf_lite_rust::bootstrap; -use ssw_jnpf_lite_rust::modules; -use ssw_jnpf_lite_rust::platform::cipher; -use ssw_jnpf_lite_rust::platform::config::Config; -use ssw_jnpf_lite_rust::platform::db::Db; -use ssw_jnpf_lite_rust::platform::guard::{self, Profile}; -use ssw_jnpf_lite_rust::platform::seed; -use ssw_jnpf_lite_rust::platform::session::SessionStore; -use ssw_jnpf_lite_rust::platform::state::AppState; -use ssw_jnpf_lite_rust::routes; +use sspf::{cipher, Config, Platform}; -/// 本仓的 **平台表**(契约 §5.1 的 7 张 `base_*`)—— 标识符白名单自检的字面量清单。 -/// -/// 🔴 **只列 `base_*`**:业务表名是**业务知识** ⇒ 写死在这里 ⇒ -/// 加一个业务模块要改入口文件 ⇒ 违反红线 12(「加一个业务模块只碰业务层」)。 -/// 业务表由 `modules::all_specs()` 派生,并与 `db/schema.sql` **对账** -/// (见 [`whitelist_self_check`])⇒ 拼错 / 漏建 / 孤儿 DDL 三种错都抓得到。 -const BASE_TABLES: [&str; 7] = [ - "base_user", - "base_role", - "base_organize", - "base_module", - "base_authorize", - "base_role_relation", - "base_user_relation", -]; - -/// 命令行解析的结果(**纯数据**,便于单测)。 -#[derive(Debug, Clone, PartialEq, Eq)] -enum Cmd { - /// `--enc <明文>` ⇒ 打印 hex 到 stdout,退出码 **0**。 - Enc(String), - /// `--enc` **缺明文** ⇒ 用法错,退出码 **2**(且必须有人话提示)。 - EncMissing, - /// `--help` / `-h` ⇒ 打印用法,退出码 **0**。 - Help, - /// 未知参数 ⇒ 用法错,退出码 **2**。 - Unknown(String), - /// 无参数 ⇒ 起服务。 - Serve, -} - -/// 解析命令行参数(**纯函数**:不读环境变量、不退出进程、不打日志)。 -/// -/// 🔴 语义逐字照搬契约 §10 的子命令条: -/// - `["--enc", <明文>]` ⇒ `Cmd::Enc`(退出码 0); -/// - `["--enc"]`(缺明文)⇒ `Cmd::EncMissing`(退出码 2 + 人话提示); -/// - `["--help"]` / `["-h"]` ⇒ `Cmd::Help`(退出码 0); -/// - `["<其它>"]` ⇒ `Cmd::Unknown`(退出码 2); -/// - `[]` ⇒ `Cmd::Serve`。 -fn parse_args(args: &[String]) -> Cmd { - match args.first().map(String::as_str) { - Some("--enc") => match args.get(1) { - Some(plain) => Cmd::Enc(plain.clone()), - None => Cmd::EncMissing, - }, - Some("--help") | Some("-h") => Cmd::Help, - Some(other) => Cmd::Unknown(other.to_string()), - None => Cmd::Serve, - } -} - -/// 子命令的**退出码**(纯函数 ⇒ 可单测)。 -/// -/// 🔴 `Cmd::Serve` ⇒ 0:起服务**不因用法出错而退出**(实际不会调用 `exit`)。 -fn exit_code(cmd: &Cmd) -> i32 { - match cmd { - Cmd::Enc(_) | Cmd::Help => 0, - Cmd::EncMissing | Cmd::Unknown(_) => 2, - Cmd::Serve => 0, - } -} +use ssw_jnpf_lite_rust::{modules, packs_gen}; #[tokio::main] async fn main() { let args: Vec = std::env::args().skip(1).collect(); - let cmd = parse_args(&args); - match &cmd { - // `--enc <明文>` ⇒ 打印 hex 到 stdout,退出码 0(冒烟脚本用它自证 cipher,不依赖 node)。 - Cmd::Enc(plain) => { - println!("{}", cipher::encrypt_password(plain)); - std::process::exit(exit_code(&cmd)); - } - Cmd::EncMissing => { - eprintln!("--enc 需要一个明文参数"); - print_usage(); - std::process::exit(exit_code(&cmd)); - } - Cmd::Help => { - print_usage(); - std::process::exit(exit_code(&cmd)); - } - Cmd::Unknown(other) => { + match args.first().map(String::as_str) { + // `--enc <明文>` ⇒ 打印 hex(冒烟脚本用它自证 cipher,不依赖 node) + Some("--enc") => match args.get(1) { + Some(plain) => println!("{}", cipher::encrypt_password(plain)), + None => { + eprintln!("--enc 需要一个明文参数"); + print_usage(); + std::process::exit(2); + } + }, + Some("--help") | Some("-h") => print_usage(), + Some(other) => { eprintln!("未知参数: {other}"); print_usage(); - std::process::exit(exit_code(&cmd)); + std::process::exit(2); } - Cmd::Serve => {} - } - - if let Err(msg) = run().await { - eprintln!("[启动失败] {msg}"); - std::process::exit(1); - } -} - -/// 打印用法(`--help` / 未知参数)。 -fn print_usage() { - println!( - "ssw-jnpf-lite-rust {} —— JNPF 兼容契约的 Rust 实现(单二进制、零外部服务)", - env!("CARGO_PKG_VERSION") - ); - println!(); - println!("用法:"); - println!(" ssw-jnpf-lite-rust 启动 HTTP 服务(默认端口 30010)"); - println!(" ssw-jnpf-lite-rust --enc <明文> 打印登录口令密文(hex),退出码 0"); - println!(" ssw-jnpf-lite-rust --help 打印本用法,退出码 0"); - println!(); - println!("环境变量:"); - println!(" PORT 监听端口(缺省 30010)"); - println!(" BIND_ADDR 监听地址(缺省 127.0.0.1 = 只监听本机;要对外暴露设 0.0.0.0)"); - println!(" PGLITE_DIR pglite 数据目录;设成 memory:// 用临时库(进程退出即销毁)"); -} - -/// 启动装配(契约 §10 的 1~7 步)。 -async fn run() -> Result<(), String> { - // ---- 第 1 步:定位项目根(与 cwd 解耦)---- - let project_dir = resolve_project_dir(); - - // ---- 第 2 步:配置 ---- - let config = Config::from_env(project_dir); - - // ---- 第 3 步:标识符白名单自检(**开库之前**)---- - if let Err(msg) = whitelist_self_check() { - return Err(format!("标识符白名单自检未通过: {msg}")); - } - - // ---- 第 4 步:开库 + 建表 ---- - let db = open_db(&config).await.map_err(|e| format!("打开数据库失败: {e}"))?; - db.ensure_schema() - .await - .map_err(|e| format!("初始化表结构失败: {e}"))?; - - // ---- 第 5 步:两段式种子 ---- - // - // 🔴 走**装配根** [`ssw_jnpf_lite_rust::bootstrap`]:它把业务层声明的菜单 - // 注入平台层的种子 ⇒ 平台层不认业务知识(红线 12)。 - bootstrap::ensure_base(&db) - .await - .map_err(|e| format!("内置角色/菜单种子失败: {e}"))?; - seed::first_seed(&db, &config.seed_admin_password) - .await - .map_err(|e| format!("初始 admin 种子失败: {e}"))?; - - // ---- 第 5b 步:生产档弱密钥守卫(**只有 `SSW_PROFILE=prod` 才生效**)---- - // - // 🔴 **两道检查**(缺一不可): - // ① 配置级:本次启动用的种子口令本身是不是弱口令; - // ② 库内级:库里 admin 那行的口令**是不是已知弱口令**—— - // 种子口令只对**空库**生效 ⇒ 生产库里那个可能是当初种下的 `123456`, - // 运维后来才设了 `SEED_ADMIN_PASSWORD` ⇒ **只查配置 = 守卫形同虚设**。 - if config.profile == Profile::Prod { - let values = vec![( - "SEED_ADMIN_PASSWORD".to_string(), - config.seed_admin_password.clone(), - )]; - let violations = guard::check_values(&values); - if !violations.is_empty() { - return Err(format!( - "生产档弱密钥守卫未通过(SSW_PROFILE=prod):\n{}", - guard::render_violations(&violations) - )); - } - guard::verify_stored_admin_password(&db) - .await - .map_err(|e| format!("生产档弱密钥守卫未通过(SSW_PROFILE=prod):{e}"))?; - } - - let state = AppState { - config: Arc::new(config.clone()), - db: Arc::new(db), - sessions: Arc::new(SessionStore::new()), - }; - // 🔴 保留一个 `Db` 句柄用于**停机时优雅关闭**嵌入式 PG(`state` 会被 `build_app` 吃掉)。 - let db_for_shutdown = state.db.clone(); - - // ---- 第 6 步:路由装配 + 三层兜底 ---- - // 🔴 装配链**只有一份**:`routes::build_app` —— S25 的顺序(`.fallback()` 在两个 - // `.layer()` **之前**、`.with_state()` 是**链尾**)就写在那儿。 - // 生产与单测走**同一条路** ⇒ 以后改顺序,两边一起变。 - let app = routes::build_app(state); - - // ---- 第 7 步:绑定端口 ---- - // 🔴 **默认只监听 127.0.0.1**(`BIND_ADDR` 可覆盖)⇒ 与「文档写的就是 127.0.0.1」一致, - // 也避免「弱口令 + token 永不过期」的后端被局域网直接连上。 - let addr = std::net::SocketAddr::new(config.bind_addr, config.port); - let listener = tokio::net::TcpListener::bind(addr) - .await - .map_err(|e| format!("绑定 {addr} 失败: {e}"))?; - - // 🔴 IPv6 的 `SocketAddr` 显示成 `::1:30010`(**不带方括号**)⇒ 直接拼进 URL 是 - // **非法 URL**(`http://::1:30010`)⇒ IPv6 主机名必须自己加方括号。 - let url_host = if addr.is_ipv6() { - format!("[{}]", addr.ip()) - } else { - addr.ip().to_string() - }; - println!( - "ssw-jnpf-lite-rust {} 已启动:http://{url_host}:{}(数据目录 {})", - env!("CARGO_PKG_VERSION"), - addr.port(), - config.pg_dir.display() - ); - - // 🔴 **优雅停机**:收到 SIGTERM / SIGINT ⇒ 先让 HTTP 服务收完在途请求,再关嵌入式 PG。 - // (以前 SIGTERM 被忽略 ⇒ 每次停机都是 SIGKILL 掉嵌入式 PostgreSQL ⇒ 下次启动要 - // crash recovery,数据目录里还留 `postmaster.pid`。) - axum::serve(listener, app) - .with_graceful_shutdown(shutdown_signal()) - .await - .map_err(|e| format!("HTTP 服务异常退出: {e}"))?; - - // ---- 停机:优雅关闭嵌入式 PostgreSQL ---- - // 🔴 **不 await** pglite 的关闭 future:pglite-rs 0.2.7 的 `PGlite::shutdown()` 给嵌入式 PG - // 发完 Terminate 之后**不会返回** —— PG 的 postmaster 会进入「拉起后端 → 后端读不到 - // 完整协议 → FATAL → 再拉起」的循环(实测一次停机刷 30 多万行日志),收尾线程卡死在那儿。 - // ⇒ 另起任务去发 Terminate,同时**盯住 `postmaster.pid` 何时消失** - // (PG 干净关库的**权威信号**)⇒ 一旦消失就立刻结束进程 - // (顺带把 pglite 那段日志噪声压到最小)。 - let shutdown_db = db_for_shutdown.clone(); - tokio::spawn(async move { - if let Err(e) = shutdown_db.shutdown().await { - eprintln!("[停机] 关闭嵌入式 PostgreSQL 失败: {e}"); - } - }); - - let pid_file = config.pg_dir.join("postmaster.pid"); - // 🔴 **先记下 pid 文件一开始在不在** —— 「不在」有两种含义,含义不同、结论也不同: - // ① 数据目录已知、PG 刚关完(`postmaster.pid` 已被 PG 自己删掉); - // ② 临时库模式(`PGLITE_DIR=memory://`)⇒ `pg_dir` 就是字面量 "memory://", - // 拼出来的 "memory://postmaster.pid" **永远不存在** ⇒ 关库状态**无从校验**。 - // ⇒ ② 不能报「已优雅关闭」(那是**没校验过**的断言),只能如实说「未校验」。 - let pid_file_known = pid_file.exists(); - let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(3); - if pid_file_known { - // 数据目录已知 ⇒ 等 `postmaster.pid` 消失(= PG 已干净关库)。 - while pid_file.exists() && tokio::time::Instant::now() < deadline { - tokio::time::sleep(std::time::Duration::from_millis(5)).await; - } - } else { - // 临时库(`PGLITE_DIR=memory://`)⇒ 数据目录路径不可知 ⇒ 退化成「固定等 200ms」 - //(实测嵌入式 PG 的干净关库只要几毫秒)。 - tokio::time::sleep(std::time::Duration::from_millis(200)).await; - } - - if !pid_file_known { - println!("ssw-jnpf-lite-rust 已停止(临时库模式:数据目录不可知,未校验嵌入式 PostgreSQL 的关库状态)。"); - } else if pid_file.exists() { - eprintln!("[停机] ⚠️ 嵌入式 PostgreSQL 未在 3 秒内干净关库(`postmaster.pid` 仍在)"); - } else { - println!("ssw-jnpf-lite-rust 已停止(嵌入式 PostgreSQL 已优雅关闭)。"); - } - // 🔴 明确结束进程:pglite 的收尾线程可能卡死 ⇒ 不能让它吊住整个进程。 - std::process::exit(0); -} - -/// 等待**停机信号**(SIGTERM / SIGINT)—— 任一到来即返回。 -/// -/// 🔴 **只影响关停**,不改变任何请求处理路径的行为(契约一字不改)。 -/// 🔴 tokio 的 `signal` feature 已在 workspace 的 `features = ["full"]` 里 ⇒ **不新增依赖**。 -async fn shutdown_signal() { - #[cfg(unix)] - { - use tokio::signal::unix::{signal, SignalKind}; - - let mut term = match signal(SignalKind::terminate()) { - Ok(s) => s, - Err(e) => { - eprintln!("[停机] 注册 SIGTERM 失败(回落 Ctrl-C):{e}"); - let _ = tokio::signal::ctrl_c().await; - return; + None => { + if let Err(msg) = serve().await { + eprintln!("[启动失败] {msg}"); + std::process::exit(1); } - }; - let mut intr = match signal(SignalKind::interrupt()) { - Ok(s) => s, - Err(e) => { - eprintln!("[停机] 注册 SIGINT 失败(只等 SIGTERM):{e}"); - term.recv().await; - return; - } - }; - - tokio::select! { - _ = term.recv() => {} - _ = intr.recv() => {} } } - #[cfg(not(unix))] - { - let _ = tokio::signal::ctrl_c().await; - } } -/// 从可执行文件向上找项目根(**与 cwd 解耦**)。 +/// 起服务:把「配置 + 业务包 + 面 A 路由 + 前端产物」交给平台。 +async fn serve() -> Result<(), String> { + let config = Config::from_env(resolve_project_dir()); + + let reg = packs_gen::registry(sspf::kernel::bootstrap::kernel_version()) + .map_err(|e| format!("业务包装载失败: {e}"))?; + + let mut platform = Platform::new() + .config(config.clone()) + .packs(reg) + .router(modules::router()); + + // 🔴 前端产物目录(`/src/frontend/dist`)—— 已经打好包,直接托管。 + // 不存在 ⇒ 不挂静态(纯 API 模式,冒烟脚本就是这么跑的)。 + if let Some(dist) = config.static_dir.clone() { + platform = platform.static_dir(dist); + } + + platform.serve().await +} + +/// 定位**项目根**(仓库根,含 `Cargo.toml` + `packs/` + `src/frontend/`)。 /// -/// 锚点:`/src/backend/db/schema.sql` **与** `/Cargo.toml`(两个都要在)。 -/// 找不到 ⇒ 回落 `current_dir()`。 +/// 为什么不用 cwd:后台 / launchd / IDE 启动时 cwd 会漂到别处, +/// 而数据目录与前端产物都挂在项目根上 ⇒ 用**可执行文件向上找锚点**。 +/// +/// 顺序: +/// 1. `SSW_PROJECT_DIR`(显式覆盖,测试 / 部署用); +/// 2. 从可执行文件向上找「同时有 `Cargo.toml` 与 `packs/` 的目录」; +/// 3. 回落 cwd(不 panic —— 路径不对只是数据目录换个地方,不该起不来)。 fn resolve_project_dir() -> PathBuf { + if let Ok(dir) = std::env::var("SSW_PROJECT_DIR") { + if !dir.trim().is_empty() { + return PathBuf::from(dir.trim()); + } + } + let start = std::env::current_exe() .ok() .and_then(|exe| exe.parent().map(|p| p.to_path_buf())); let mut dir = start; while let Some(cur) = dir { - if cur.join("src/backend/db/schema.sql").is_file() && cur.join("Cargo.toml").is_file() { + if cur.join("Cargo.toml").is_file() && cur.join("packs").is_dir() { return cur; } dir = cur.parent().map(|p| p.to_path_buf()); @@ -345,153 +109,21 @@ fn resolve_project_dir() -> PathBuf { std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")) } -/// 标识符白名单自检(控制器裁决 S24)—— **开库之前**跑。 -/// -/// 检查对象 = 本仓真正会被拼进 SQL 文本的标识符: -/// 1. **业务 spec**(`modules::all_specs()`):`spec.table` 过 `db::valid_table`; -/// 每个 `col.column` 过 `db::valid_column`; -/// 2. **10 张表的字面量清单** [`EXPECTED_TABLES`]:每个过 `db::valid_table`; -/// 3. **额外**:spec 的 `spec.table` 必须出现在 [`EXPECTED_TABLES`] 里。 -/// -/// 🔴 **明确不查**(控制器裁定的已知简化):`sys.rs` 的 4 组投影列常量 -/// (`USER_COLUMNS` 等)—— 它们是源码里的字面量常量,不是运行时输入; -/// 真写错了编译期 SQL 就已经炸 ⇒ 启动自检对它们没有防错价值。 -/// -/// 本函数是**兜底 tripwire**,不是完备证明。 -fn whitelist_self_check() -> Result<(), String> { - for table in BASE_TABLES { - if ssw_jnpf_lite_rust::platform::db::valid_table(table).is_none() { - return Err(format!("表名 {table} 未过标识符白名单")); - } - } - - for spec in modules::all_specs() { - if ssw_jnpf_lite_rust::platform::db::valid_table(spec.table).is_none() { - return Err(format!("spec 表名 {} 未过标识符白名单", spec.table)); - } - for col in spec.columns { - if ssw_jnpf_lite_rust::platform::db::valid_column(col.column).is_none() { - return Err(format!( - "spec 列名 {}.{} 未过标识符白名单", - spec.table, col.column - )); - } - } - } - - // ---- 与 DDL 对账(`db/schema.sql` 是数据模型真源)---- - // - // 🔴 **为什么不用「写死的表名清单」**:那张清单里若含业务表名 ⇒ - // 加业务模块要改入口文件 ⇒ 违反红线 12。 - // 改为「清单 = 7 张 base_* + 业务层 spec 派生的表」, - // 再与 DDL **双向**对账 ⇒ 下面三类错都抓得到: - // ① spec 表名拼错(合法标识符但 DDL 里没有)⇒ 启动失败; - // ② DDL 里有表但没有任何 spec 声明它 ⇒ 启动失败(孤儿 DDL); - // ③ DDL 缺表(spec 声明了但没建表)⇒ 启动失败。 - let spec_tables: Vec<&str> = modules::all_specs().iter().map(|s| s.table).collect(); - let ddl_tables = ssw_jnpf_lite_rust::platform::db::ddl_tables(); - - for table in &ddl_tables { - if !BASE_TABLES.contains(&table.as_str()) && !spec_tables.contains(&table.as_str()) { - return Err(format!( - "schema.sql 里的表 {table} 既不是 base_* 表、也没有对应的业务 spec(孤儿 DDL?)" - )); - } - } - for table in &spec_tables { - if !ddl_tables.iter().any(|t| t == table) { - return Err(format!( - "spec 表 {table} 在 db/schema.sql 里没有 CREATE TABLE(漏建表?)" - )); - } - } - - Ok(()) -} - -/// 开库:`PGLITE_DIR=memory://` ⇒ 临时库(进程退出即销毁);否则磁盘目录。 -async fn open_db(config: &Config) -> Result { - if config.pg_is_temp() { - Db::open_temp().await - } else { - Db::open(&config.pg_dir).await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn args(list: &[&str]) -> Vec { - list.iter().map(|s| s.to_string()).collect() - } - - /// `--enc <明文>` ⇒ `Cmd::Enc` + 退出码 **0**。 - #[test] - fn enc_with_plaintext_exits_zero() { - let cmd = parse_args(&args(&["--enc", "123456"])); - assert_eq!(cmd, Cmd::Enc("123456".to_string())); - assert_eq!(exit_code(&cmd), 0); - } - - /// `--enc` **缺明文** ⇒ 用法错 ⇒ 退出码 **2**(不是 0,也不是 1)。 - #[test] - fn enc_without_plaintext_exits_two() { - let cmd = parse_args(&args(&["--enc"])); - assert_eq!(cmd, Cmd::EncMissing); - assert_eq!(exit_code(&cmd), 2); - } - - /// `--help` / `-h` ⇒ `Cmd::Help` + 退出码 **0**。 - #[test] - fn help_variants_exit_zero() { - for flag in ["--help", "-h"] { - let cmd = parse_args(&args(&[flag])); - assert_eq!(cmd, Cmd::Help, "flag {flag} 必须是 Help"); - assert_eq!(exit_code(&cmd), 0, "flag {flag} 必须退出码 0"); - } - } - - /// 未知参数 ⇒ 用法错 ⇒ 退出码 **2**。 - #[test] - fn unknown_flag_exits_two() { - let cmd = parse_args(&args(&["--bogus"])); - assert_eq!(cmd, Cmd::Unknown("--bogus".to_string())); - assert_eq!(exit_code(&cmd), 2); - } - - /// 无参数 ⇒ **起服务**(不是退出码)。 - #[test] - fn empty_args_mean_serve() { - assert_eq!(parse_args(&args(&[])), Cmd::Serve); - } - - /// 🔴 **表清单与 DDL 对得上** —— 加了业务表却忘了加 DDL(或反之)⇒ 这里红。 - #[test] - fn whitelist_self_check_passes_for_this_repo() { - // 🔴 这条钉住「表清单与 DDL 对得上」:加了业务表却忘了加 DDL(或反之)⇒ 这里红。 - whitelist_self_check().expect("本仓的表清单与 db/schema.sql 必须对得上"); - } - - /// 🔴 **入口文件不许写死业务表名**(红线 12)—— 加业务模块不改入口。 - #[test] - fn entry_point_does_not_name_business_tables() { - let base: Vec<&str> = BASE_TABLES.to_vec(); - for spec in modules::all_specs() { - assert!( - !base.contains(&spec.table), - "BASE_TABLES 里不许出现业务表 {}", - spec.table - ); - } - } - - /// 🔴 解析是**纯函数** —— 同一个 args 反复解析结果恒等(不依赖环境变量 / 进程状态)。 - #[test] - fn parse_args_is_pure() { - let a = args(&["--enc", "123456"]); - let b = a.clone(); - assert_eq!(parse_args(&a), parse_args(&b)); - assert_eq!(parse_args(&a), Cmd::Enc("123456".to_string())); - } +fn print_usage() { + println!( + "ssw-jnpf-lite-rust —— 基于 sspf v{} 的示例业务装配(单二进制、零外部服务)", + sspf::VERSION + ); + println!(); + println!("用法:"); + println!(" ssw-jnpf-lite-rust 启动 HTTP 服务(默认端口 30010)"); + println!(" ssw-jnpf-lite-rust --enc <明文> 打印登录口令密文(hex),退出码 0"); + println!(" ssw-jnpf-lite-rust --help 打印本用法,退出码 0"); + println!(); + println!("环境变量:"); + println!(" PORT 监听端口(缺省 30010)"); + println!(" BIND_ADDR 监听地址(缺省 127.0.0.1 = 只监听本机)"); + println!(" PGLITE_DIR pglite 数据目录;设成 memory:// 用临时库"); + println!(" SSW_PROFILE 部署档位(prod/production = 生产档;缺省 = 开发档)"); + println!(" SSW_PROJECT_DIR 项目根(缺省从可执行文件向上找 Cargo.toml + packs/)"); } diff --git a/src/backend/src/modules/asset.rs b/src/backend/src/modules/asset.rs new file mode 100644 index 0000000..488c2aa --- /dev/null +++ b/src/backend/src/modules/asset.rs @@ -0,0 +1,88 @@ +//! asset —— 业务模块:DataResource(物理表 `asset_data_resource`)。 +//! +//! 🔴 **本文件是「spec 的转发点」,不是 spec 的家**(批次 12 交付物 ②): +//! 真正的 spec 在 `packs/asset/src/lib.rs`(业务包,**只依赖 sspf-sdk**), +//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**。 +//! +//! 🔴 **为什么这么改**(原来的问题是「两份逐字拷贝」): +//! 改一处忘另一处 ⇒ **静默**不一致(而且没有任何闸门比对它们 —— +//! `packs/asset` 的注释写着「PACK1 会比对」,但 PACK1 **至今没实现**)。 +//! ⇒ 现在:spec 在包里 ⇒ 改 spec 只改一处 ⇒ PACK1 闸门校验「模块文件只许 re-export」。 +//! +//! 🔴 **【集成期友好性】面 A 与面 B 各住一处**(批次 12 交付物 ①): +//! - **本文件 = 面 A**(`/api/ssw/asset/DataResource/…`)—— 本仓自造的 ssw 约定, +//! **留给 Rust 终端场景**,**一个字都不改**; +//! - **业务包 = 面 B**(`/api/asset/DataResource/…`)—— 官方 JNPF 形状, +//! 集成到官方 Java 时**能直接搬**(`技能仓 MIGRATION.md` §2.3 的逐条对照表)。 +//! +//! 🔴 **两套路由不冲突**(路径不同)⇒ 面 A 的前端零改、面 B 的集成期零改。 +//! +//! 🔴 **业务 DDL 跟着包走**(批次 12 交付物 ③):`asset_data_resource` 的建表语句 +//! 在 `packs/asset/schema/001_init.sql`,**编译进二进制**(`include_str!`), +//! 不再手抄进 `db/schema.sql`。 + +use axum::body::Bytes; +use axum::extract::{RawQuery, State}; +use axum::http::HeaderMap; +use axum::routing::{delete, get, post}; +use axum::{Json, Router}; + +use sspf::crud::{handle_delete, handle_list, handle_save}; +use sspf::envelope::ActionResult; +use sspf::AppState; + +// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。 +pub use sspf_pack_asset::DATA_RESOURCE_MENU; +pub use sspf_pack_asset::DATA_RESOURCE_SPEC; + +/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。 +/// +/// 🔴 路径是**面 A 的 ssw 形状**(`/api/ssw/{appCode}/{Entity}/{动作}`)—— +/// 业务包声明的**面 B**(官方形状)在 `packs/asset/src/lib.rs`, +/// 由内核按声明生成(见 `bootstrap::pack_router`)。 +pub const ROUTES: [&str; 3] = [ + "/api/ssw/asset/DataResource/List", + "/api/ssw/asset/DataResource/Save", + "/api/ssw/asset/DataResource/Delete", +]; + +/// `GET /api/ssw/asset/DataResource/List`。 +pub async fn data_resource_list( + State(state): State, + headers: HeaderMap, +) -> Json { + handle_list(&state, &headers, &DATA_RESOURCE_SPEC).await +} + +/// `POST /api/ssw/asset/DataResource/Save`。 +pub async fn data_resource_save( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + handle_save(&state, &headers, &DATA_RESOURCE_SPEC, &body).await +} + +/// `DELETE /api/ssw/asset/DataResource/Delete?id=`。 +pub async fn data_resource_delete( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + handle_delete(&state, &headers, &DATA_RESOURCE_SPEC, &raw).await +} + +/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。 +/// +/// 🔴 路径在这里写**字面量**(不用 `ROUTES[0]`)—— 契约扫描器 +/// `scripts/check-contract-scan.py` 是静态解析,认不出数组下标 ⇒ +/// 写成下标会让 `check-contract.sh` 判「契约登记了、代码里没有」(假飘移)。 +pub fn router() -> Router { + Router::new() + .route("/api/ssw/asset/DataResource/List", get(data_resource_list)) + .route("/api/ssw/asset/DataResource/Save", post(data_resource_save)) + .route( + "/api/ssw/asset/DataResource/Delete", + delete(data_resource_delete), + ) +} diff --git a/src/backend/src/modules/books.rs b/src/backend/src/modules/books.rs index f28e48a..a901889 100644 --- a/src/backend/src/modules/books.rs +++ b/src/backend/src/modules/books.rs @@ -1,14 +1,20 @@ //! books —— 业务模块:Book(物理表 `book_shop_book`)。 //! -//! 🔴 **业务层模板**:加一个业务模块 = 照抄本文件建 `modules/.rs` -//! (spec + 3 个 handler + 自己的路由),**再在 [`crate::modules::mod`] 里挂一行**。 -//! **平台层(`platform/`)一个字都不用改。** +//! 🔴 **本文件是「面 A 适配器 + spec 的转发点」,不是 spec 的家**: +//! 真源在 `packs/books/src/lib.rs`(业务包,**只依赖 sspf-sdk**), +//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**(`check-arch.sh` 的 PACK1 钉住)。 //! -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/books/book.entity.ts` -//! (**列名 / 列序逐字对齐** —— 两版后端要能开同一个库)。 +//! 🔴 **面 A 与面 B 各住一处**: +//! - **本文件 = 面 A**(`/api/ssw/books/Book/…`)—— 本仓自造的 ssw 约定, +//! 留给 Rust 终端场景,**一个字都不改**(前端在用它); +//! - **业务包 = 面 B**(`/api/books/Book`)—— 官方 JNPF 形状, +//! 集成到官方 Java 时能直接搬。 //! -//! 🔴 本模块的守卫:菜单 `books/Book`(`module_key`)⇒ 非管理员未授权 ⇒ `code=403`。 -//! 🔴 `f_price` 是 **numeric**(JSON 字符串 `"9.90"`)· `f_stock` 是 **int**(JSON 数字 `100`)。 +//! 🔴 **DDL 跟着包走**:`book_shop_book` 的建表语句在 `packs/books/schema/001_init.sql`, +//! 编译进二进制 ⇒ 不再手抄进 `db/schema.sql`。 +//! +//! 🔴 **本包是示例包**:`packs/books` 整目录可搬去技能当样板,本文件是它在本仓的 +//! 面 A 适配器(技能带走示例时,这份适配器可以不要)。 use axum::body::Bytes; use axum::extract::{RawQuery, State}; @@ -16,108 +22,18 @@ use axum::http::HeaderMap; use axum::routing::{delete, get, post}; use axum::{Json, Router}; -use crate::platform::crud::{handle_delete, handle_list, handle_save}; -use crate::platform::entity::{ColumnSpec, EntitySpec}; -use crate::platform::envelope::ActionResult; -use crate::platform::menu::MenuSpec; -use crate::platform::state::AppState; +use sspf::crud::{handle_delete, handle_list, handle_save}; +use sspf::envelope::ActionResult; +use sspf::AppState; -/// `book_shop_book` 的列清单(**顺序 = 响应 JSON 的键序**)。 -const BOOK_COLUMNS: &[ColumnSpec] = &[ - ColumnSpec { - column: "f_id", - json_key: "id", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_title", - json_key: "title", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_author", - json_key: "author", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_isbn", - json_key: "isbn", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_category", - json_key: "category", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_price", - json_key: "price", - default: Some("0.00"), - numeric: true, - }, - ColumnSpec { - column: "f_stock", - json_key: "stock", - default: Some("0"), - numeric: false, - }, - ColumnSpec { - column: "f_creator_user_id", - json_key: "creatorUserId", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_creator_time", - json_key: "creatorTime", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_delete_mark", - json_key: "deleteMark", - default: Some("0"), - numeric: false, - }, -]; +// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。 +pub use sspf_pack_books::BOOK_MENU; +pub use sspf_pack_books::BOOK_SPEC; -/// `book_shop_book` 的 spec。 -pub const BOOK_SPEC: EntitySpec = EntitySpec { - app_code: "books", - entity: "Book", - table: "book_shop_book", - module_key: Some("books/Book"), - columns: BOOK_COLUMNS, - numeric_columns: &["f_price"], - // 🔴 裁决 S22:非 demo 表 ⇒ `body.creatorUserId || 'admin'`。 - creator_fixed: None, -}; - -/// 🔴 **本模块的内置菜单**(契约 §8.4)—— 业务知识 ⇒ 住在**业务层**。 +/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。 /// -/// 🔴 **`url_address` 必须与 [`BOOK_SPEC`] 的 `module_key` 一字不差** -/// (都是 `books/Book`)—— 面 A 的菜单守卫靠它命中。 -pub const BOOK_MENU: MenuSpec = MenuSpec { - id: "m_book", - full_name: "图书超市", - // 🔴 **本仓自定的占位编码**(官方 JNPF 没有 books 模块)⇒ 见 `docs/known-limitations.md` §H。 - en_code: "permission.books.book", - url_address: "books/Book", - parent_id: "0", - menu_type: 2, - icon: Some("app"), - sort_code: 8, -}; - -/// 本模块的 3 条路由(**业务层的路由表**)—— 钉子测试遍历它。 -/// -/// 🔴 **业务路由清单住在业务层** ⇒ 平台层(`routes.rs`)不认业务路径 -/// ⇒ 加业务模块**不用改平台层**(平台层的钉子测试遍历本表)。 +/// 🔴 路径写字面量(不用下标):`scripts/check-contract-scan.py` 是静态解析, +/// 认不出数组下标 ⇒ 写下标会让契约闸门判「登记了、代码里没有」。 pub const ROUTES: [&str; 3] = [ "/api/ssw/books/Book/List", "/api/ssw/books/Book/Save", @@ -150,7 +66,7 @@ pub async fn book_delete( handle_delete(&state, &headers, &BOOK_SPEC, &raw).await } -/// 本模块的路由(`Router::merge` 进总路由,**对齐 NestJS 的 module 注册**)。 +/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。 pub fn router() -> Router { Router::new() .route("/api/ssw/books/Book/List", get(book_list)) diff --git a/src/backend/src/modules/demo.rs b/src/backend/src/modules/demo.rs index 65ca1da..055b438 100644 --- a/src/backend/src/modules/demo.rs +++ b/src/backend/src/modules/demo.rs @@ -1,14 +1,20 @@ //! demo —— 业务模块:DemoItem(物理表 `demo_item`)。 //! -//! 🔴 **业务层模板**:加一个业务模块 = 照抄本文件建 `modules/.rs` -//! (spec + 3 个 handler + 自己的路由),**再在 [`crate::modules::mod`] 里挂一行**。 -//! **平台层(`platform/`)一个字都不用改。** +//! 🔴 **本文件是「面 A 适配器 + spec 的转发点」,不是 spec 的家**: +//! 真源在 `packs/demo/src/lib.rs`(业务包,**只依赖 sspf-sdk**), +//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**(`check-arch.sh` 的 PACK1 钉住)。 //! -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/demo/demo-item.entity.ts` -//! (**列名 / 列序逐字对齐** —— 两版后端要能开同一个库)。 +//! 🔴 **面 A 与面 B 各住一处**: +//! - **本文件 = 面 A**(`/api/ssw/demo/DemoItem/…`)—— 本仓自造的 ssw 约定, +//! 留给 Rust 终端场景,**一个字都不改**(前端在用它); +//! - **业务包 = 面 B**(`/api/demo/DemoItem`)—— 官方 JNPF 形状, +//! 集成到官方 Java 时能直接搬。 //! -//! 🔴 本模块的特别规则(裁决 S22):`f_creator_user_id` **硬编码 `'admin'`** -//! (路径 1 完全不看 body)⇒ 由 spec 的 `creator_fixed` 声明,引擎不认 app_code。 +//! 🔴 **DDL 跟着包走**:`demo_item` 的建表语句在 `packs/demo/schema/001_init.sql`, +//! 编译进二进制 ⇒ 不再手抄进 `db/schema.sql`。 +//! +//! 🔴 **本包是示例包**:`packs/demo` 整目录可搬去技能当样板,本文件是它在本仓的 +//! 面 A 适配器(技能带走示例时,这份适配器可以不要)。 use axum::body::Bytes; use axum::extract::{RawQuery, State}; @@ -16,92 +22,18 @@ use axum::http::HeaderMap; use axum::routing::{delete, get, post}; use axum::{Json, Router}; -use crate::platform::crud::{handle_delete, handle_list, handle_save}; -use crate::platform::entity::{ColumnSpec, EntitySpec}; -use crate::platform::envelope::ActionResult; -use crate::platform::menu::MenuSpec; -use crate::platform::state::AppState; +use sspf::crud::{handle_delete, handle_list, handle_save}; +use sspf::envelope::ActionResult; +use sspf::AppState; -/// `demo_item` 的列清单(**顺序 = 响应 JSON 的键序**)。 -const DEMO_COLUMNS: &[ColumnSpec] = &[ - ColumnSpec { - column: "f_id", - json_key: "id", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_title", - json_key: "title", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_status", - json_key: "status", - default: Some("草稿"), - numeric: false, - }, - ColumnSpec { - column: "f_creator_user_id", - json_key: "creatorUserId", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_creator_time", - json_key: "creatorTime", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_delete_mark", - json_key: "deleteMark", - default: Some("0"), - numeric: false, - }, -]; +// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。 +pub use sspf_pack_demo::DEMO_MENU; +pub use sspf_pack_demo::DEMO_SPEC; -/// `demo_item` 的 spec。 +/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。 /// -/// 🔴 写成 **`const`**(而不是 `fn find_spec(..).expect(..)`)—— 非测试代码 -/// **零 `unwrap()` / `expect()` / `panic!()`** 是项目红线。 -pub const DEMO_SPEC: EntitySpec = EntitySpec { - app_code: "demo", - entity: "DemoItem", - table: "demo_item", - // 🔴 demo **仅登录**(无菜单守卫)。 - module_key: None, - columns: DEMO_COLUMNS, - numeric_columns: &[], - // 🔴 裁决 S22:demo 的 `f_creator_user_id` 恒为 `'admin'`(不看 body)。 - creator_fixed: Some("admin"), -}; - -/// 🔴 **本模块的内置菜单**(契约 §8.4)—— 业务知识 ⇒ 住在**业务层**。 -/// -/// 🔴 **为什么菜单也要下沉**:`f_url_address`(前端 Route path)与 `f_en_code` -/// (面 B 的点权限编码)都是**业务知识** ⇒ 写在平台层 ⇒ 加业务模块要改平台层 -/// ⇒ 违反红线 12(加一个业务模块只碰业务层)。 -/// -/// 🔴 **`url_address` = `demo-item`**(不是 `demo/DemoItem`)—— demo **仅登录**、 -/// 没有菜单守卫 ⇒ 它的 `f_url_address` 只用于菜单树展示 ⇒ 与前端 Route 一致。 -pub const DEMO_MENU: MenuSpec = MenuSpec { - id: "m_demo", - full_name: "Demo 示例", - // 🔴 **本仓自定的占位编码**(官方 JNPF 没有 demo 模块)⇒ 见 `docs/known-limitations.md` §H。 - en_code: "permission.demo", - url_address: "demo-item", - parent_id: "0", - menu_type: 2, - icon: Some("app"), - sort_code: 6, -}; - -/// 本模块的 3 条路由(**业务层的路由表**)—— 钉子测试遍历它。 -/// -/// 🔴 **业务路由清单住在业务层** ⇒ 平台层(`routes.rs`)不认业务路径 -/// ⇒ 加业务模块**不用改平台层**(平台层的钉子测试遍历本表)。 +/// 🔴 路径写字面量(不用下标):`scripts/check-contract-scan.py` 是静态解析, +/// 认不出数组下标 ⇒ 写下标会让契约闸门判「登记了、代码里没有」。 pub const ROUTES: [&str; 3] = [ "/api/ssw/demo/DemoItem/List", "/api/ssw/demo/DemoItem/Save", @@ -134,7 +66,7 @@ pub async fn demo_item_delete( handle_delete(&state, &headers, &DEMO_SPEC, &raw).await } -/// 本模块的路由(`Router::merge` 进总路由,**对齐 NestJS 的 module 注册**)。 +/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。 pub fn router() -> Router { Router::new() .route("/api/ssw/demo/DemoItem/List", get(demo_item_list)) diff --git a/src/backend/src/modules/mod.rs b/src/backend/src/modules/mod.rs index acee193..d2c9eea 100644 --- a/src/backend/src/modules/mod.rs +++ b/src/backend/src/modules/mod.rs @@ -1,67 +1,88 @@ -//! modules —— **业务层**:三个业务模块(demo / shop / books)+ spec 登记表。 +//! modules —— **面 A 适配器 + 业务登记表**(业务仓唯一「加模块要碰」的目录之一)。 //! -//! 🔴 **加一个业务模块只碰本目录**(平台层 `platform/` 一行都不用改): -//! 1. 照抄 `demo.rs` 建 `modules/.rs`:列清单 + `EntitySpec` + 3 个 handler + `router()`; -//! 2. 在本文件的 [`router()`] 里 merge 一行、在 [`ALL_SPECS`] 里加一条; -//! 3. 业务表 DDL 加进 `db/schema.sql`(react 侧靠 TypeORM `synchronize` 自动建表,**rust 没有**)。 +//! 🔴 **加一个业务模块不用手改本文件**(生成段由 `scripts/pack-sync.py` 补齐): //! -//! 分层对照(与 react 版、官方 JNPF Java 一致): +//! ```bash +//! bash scripts/new-pack.sh --name "中文名" --columns "a:VARCHAR(200)" +//! ``` //! -//! | react 版 | rust 版 | 官方 JNPF Java | -//! |---|---|---| -//! | `src/backend/src/{demo,shop,books}/` | **`crate::modules`** | `jnpf-admin` | -//! | `src/backend/src/{common,auth,sys}/` | `crate::platform` | `jnpf-common` + `jnpf-system` | +//! 它会建 `packs//`(**真源**:表 DDL + 列 + 菜单 + 面 B 路由)+ 本目录的 +//! `.rs`(面 A 适配器),然后跑 `pack-sync.py` 把下面的生成段补齐。 +//! +//! 🔴 **`// >>>GEN:xxx` 与 `// <<>>GEN:MODS +pub mod asset; pub mod books; pub mod demo; pub mod shop; +// <<>>GEN:SPECS +/// 全部业务实体 spec。 +/// +/// 🔴 **本段由 `scripts/pack-sync.py` 生成** —— 加模块不用手改(见文件头)。 pub const ALL_SPECS: &[EntitySpec] = &[ + asset::DATA_RESOURCE_SPEC, + books::BOOK_SPEC, demo::DEMO_SPEC, shop::PRODUCT_SPEC, - books::BOOK_SPEC, ]; +// <<>>GEN:ROUTES +/// **全部业务路由**(面 A:`/api/ssw/{appCode}/{Entity}/{动作}`,每模块 3 条)。 /// -/// 🔴 **业务路由清单住在业务层** ⇒ 平台层(`routes.rs`)不认业务路径 -/// ⇒ 加业务模块**不用改平台层**(平台层只 merge 一次 [`router()`])。 +/// 🔴 **与 `ALL_SPECS` 同序**(同一份模块清单生成)⇒ 可以按 3 条一组配对。 pub const ALL_ROUTES: &[&str] = &[ + asset::ROUTES[0], + asset::ROUTES[1], + asset::ROUTES[2], + books::ROUTES[0], + books::ROUTES[1], + books::ROUTES[2], demo::ROUTES[0], demo::ROUTES[1], demo::ROUTES[2], shop::ROUTES[0], shop::ROUTES[1], shop::ROUTES[2], - books::ROUTES[0], - books::ROUTES[1], - books::ROUTES[2], ]; +// <<>>GEN:MENUS +/// 全部业务内置菜单(**给人看的快照**)。 /// -/// 🔴 顺序 = 各模块声明的顺序(demo → shop → books)⇒ 与契约 §8.4 的 -/// `f_sort_code` 6 / 7 / 8 对齐。 +/// 🔴 真正种进库的是 `packs/*` 里 `BusinessPack::menus()` 的那一份 +/// (`sspf::Platform::packs(reg)` 把 `PackRegistry.menus` 直接带进两段式种子)。 +/// **不要再把本数组传给 `.menus()`** —— 同一份菜单给两次,种子 INSERT 会撞主键。 +/// 这里留着是给测试 / 排障一个稳定的、不依赖装载流程的清单。 pub const ALL_MENUS: &[MenuSpec] = &[ + asset::DATA_RESOURCE_MENU, + books::BOOK_MENU, demo::DEMO_MENU, shop::PRODUCT_MENU, - books::BOOK_MENU, ]; +// << &'static [EntitySpec] { ALL_SPECS } -/// 全部业务内置菜单。 +/// 全部业务内置菜单(快照,见 [`ALL_MENUS`] 的注释)。 pub fn all_menus() -> &'static [MenuSpec] { ALL_MENUS } @@ -73,25 +94,30 @@ pub fn find_spec(app_code: &str, entity: &str) -> Option<&'static EntitySpec> { .find(|s| s.app_code == app_code && s.entity == entity) } -/// **全部业务模块的路由**(`Router::merge` 进总路由)。 +// >>>GEN:ROUTER +/// **全部业务模块的路由**(面 A,`Router::merge` 进平台装配链)。 /// -/// 🔴 加业务模块 ⇒ 在这里 merge 一行(**业务目录内**,平台层不动)。 +/// 🔴 加业务模块 ⇒ **不用改这里**(本段由 `pack-sync.py` 生成)。 pub fn router() -> Router { - demo::router() - .merge(shop::router()) + asset::router() .merge(books::router()) + .merge(demo::router()) + .merge(shop::router()) } +// <<= 4, "至少要有 demo/shop/books/asset 四个示例模块"); for (i, s) in specs.iter().enumerate() { for other in &specs[i + 1..] { assert!( @@ -105,200 +131,18 @@ mod tests { assert!(find_spec("demo", "DemoItem").is_some()); assert!(find_spec("shop", "Product").is_some()); assert!(find_spec("books", "Book").is_some()); + assert!(find_spec("asset", "DataResource").is_some()); assert!(find_spec("demo", "Product").is_none()); assert!(find_spec("nope", "Book").is_none()); } - /// 🔴 每列的 `json_key` 必须等于 `db::column_to_json_key(column)` - /// (`f_title` ⇒ `title`)—— 不一致 ⇒ 投影别名与 body 键会对不上,且**静默**。 + /// 🔴 面 A 路由条数 = 模块数 × 3(List / Save / Delete)。 #[test] - fn every_json_key_matches_the_contract_mapping() { - for spec in all_specs() { - for col in spec.columns { - assert_eq!( - db::column_to_json_key(col.column), - col.json_key, - "{} 的 {} 的 json_key 不对", - spec.table, - col.column - ); - } - } - } - - /// `numeric_columns` 与每列的 `numeric` 标记必须一致。 - #[test] - fn numeric_columns_matches_column_flags() { - for spec in all_specs() { - for col in spec.columns { - let listed = spec.numeric_columns.contains(&col.column); - assert_eq!( - listed, col.numeric, - "{} 的 {} 的 numeric 标记与 numeric_columns 不一致", - spec.table, col.column - ); - } - } - } - - /// 契约 §5.3 的三张表列清单(**逐字**):列名与列序。 - #[test] - fn column_sets_match_contract_5_3() { - let names = |spec: &EntitySpec| -> Vec<&str> { - spec.columns.iter().map(|c| c.column).collect() - }; - let demo = find_spec("demo", "DemoItem").expect("demo spec"); + fn every_module_registers_three_face_a_routes() { assert_eq!( - names(demo), - vec![ - "f_id", - "f_title", - "f_status", - "f_creator_user_id", - "f_creator_time", - "f_delete_mark" - ] + ALL_ROUTES.len(), + all_specs().len() * 3, + "ALL_ROUTES 必须每个模块 3 条(与 ALL_SPECS 同序)" ); - let product = find_spec("shop", "Product").expect("shop spec"); - assert_eq!( - names(product), - vec![ - "f_id", - "f_title", - "f_price", - "f_creator_user_id", - "f_creator_time", - "f_delete_mark" - ] - ); - let book = find_spec("books", "Book").expect("books spec"); - assert_eq!( - names(book), - vec![ - "f_id", - "f_title", - "f_author", - "f_isbn", - "f_category", - "f_price", - "f_stock", - "f_creator_user_id", - "f_creator_time", - "f_delete_mark" - ] - ); - } - - /// 守卫 key:demo 仅登录,另两个有菜单守卫。 - #[test] - fn module_keys_are_as_specified() { - assert_eq!(find_spec("demo", "DemoItem").unwrap().module_key, None); - assert_eq!( - find_spec("shop", "Product").unwrap().module_key, - Some("shop/Product") - ); - assert_eq!( - find_spec("books", "Book").unwrap().module_key, - Some("books/Book") - ); - } - - /// 表名必须过白名单(拼进 SQL 前还要再过一次,但 spec 本身就应当是合法标识符)。 - #[test] - fn table_names_are_valid_identifiers() { - for spec in all_specs() { - assert!(db::valid_table(spec.table).is_some(), "非法表名: {}", spec.table); - for col in spec.columns { - assert!( - db::valid_column(col.column).is_some(), - "非法列名: {}", - col.column - ); - } - } - } - - /// 🔴 裁决 S22:`f_creator_user_id` 的写死规则**由业务 spec 声明**,平台层不认 app_code。 - #[test] - fn creator_fixed_rules_are_declared_by_the_business_specs() { - assert_eq!( - find_spec("demo", "DemoItem").unwrap().creator_fixed, - Some("admin") - ); - assert_eq!(find_spec("shop", "Product").unwrap().creator_fixed, None); - assert_eq!(find_spec("books", "Book").unwrap().creator_fixed, None); - } - - /// 🔴 **业务路由的形状钉死** —— 每条必须是 `/api/ssw/{app_code}/{entity}/{List|Save|Delete}`。 - /// - /// 🔴 **业务路由清单住在业务层** ⇒ 平台层的钉子测试遍历 [`ALL_ROUTES`], - /// 加业务模块**不用改平台层** ⇒ 这里的形状约束就是唯一的守门人。 - #[test] - fn business_routes_follow_the_contract_shape() { - // 每个模块的 3 条路由 + 汇总表必须一致(不重不漏)。 - let per_module: Vec<&str> = demo::ROUTES - .iter() - .chain(shop::ROUTES.iter()) - .chain(books::ROUTES.iter()) - .copied() - .collect(); - assert_eq!( - per_module, ALL_ROUTES.to_vec(), - "ALL_ROUTES 必须等于各模块 ROUTES 的顺序拼接" - ); - - for (spec, routes) in ALL_SPECS - .iter() - .zip([demo::ROUTES, shop::ROUTES, books::ROUTES]) - { - assert_eq!(routes.len(), 3, "{} 必须有 3 条路由", spec.entity); - for (path, action) in routes.iter().zip(["List", "Save", "Delete"]) { - let expected = format!("/api/ssw/{}/{}/{}", spec.app_code, spec.entity, action); - assert_eq!( - *path, expected, - "{} 的路由形状不对(契约:/api/ssw/{{appCode}}/{{Entity}}/{{List|Save|Delete}})", - spec.entity - ); - } - } - } - - /// 🔴 **菜单的 `url_address` 必须与 spec 的 `module_key` 一字不差**(有守卫的模块)。 - /// - /// 🔴 三处必须一致:① 菜单的 `f_url_address` ② spec 的 `module_key` - /// ③ 前端 `` —— 任一不一致 ⇒ 菜单显示了但守卫不命中 - /// (或反过来)⇒ **静默**失败。 - #[test] - fn menu_url_matches_module_key() { - for (spec, menu) in ALL_SPECS.iter().zip(ALL_MENUS.iter()) { - if let Some(key) = spec.module_key { - assert_eq!( - Some(menu.url_address), - Some(key), - "{} 的菜单 url_address 与 module_key 不一致", - spec.entity - ); - } - } - } - - /// 🔴 **菜单 id / url 必须唯一**(id 是种子 INSERT 的固定字面量主键 ⇒ 撞了就 exit 1)。 - #[test] - fn menus_are_unique() { - for (i, m) in ALL_MENUS.iter().enumerate() { - for other in &ALL_MENUS[i + 1..] { - assert_ne!(m.id, other.id, "菜单 id 重复: {}", m.id); - assert_ne!( - m.url_address, other.url_address, - "菜单 url_address 重复: {}", m.url_address - ); - } - } - } - - /// 🔴 **菜单数 = 业务模块数** —— 加一个业务模块时,两处必须同时加。 - #[test] - fn menu_count_matches_spec_count() { - assert_eq!(ALL_MENUS.len(), ALL_SPECS.len()); } } diff --git a/src/backend/src/modules/shop.rs b/src/backend/src/modules/shop.rs index d7af309..130c1f9 100644 --- a/src/backend/src/modules/shop.rs +++ b/src/backend/src/modules/shop.rs @@ -1,13 +1,20 @@ //! shop —— 业务模块:Product(物理表 `shop_product`)。 //! -//! 🔴 **业务层模板**:加一个业务模块 = 照抄本文件建 `modules/.rs` -//! (spec + 3 个 handler + 自己的路由),**再在 [`crate::modules::mod`] 里挂一行**。 -//! **平台层(`platform/`)一个字都不用改。** +//! 🔴 **本文件是「面 A 适配器 + spec 的转发点」,不是 spec 的家**: +//! 真源在 `packs/shop/src/lib.rs`(业务包,**只依赖 sspf-sdk**), +//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**(`check-arch.sh` 的 PACK1 钉住)。 //! -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/shop/product.entity.ts` -//! (**列名 / 列序逐字对齐** —— 两版后端要能开同一个库)。 +//! 🔴 **面 A 与面 B 各住一处**: +//! - **本文件 = 面 A**(`/api/ssw/shop/Product/…`)—— 本仓自造的 ssw 约定, +//! 留给 Rust 终端场景,**一个字都不改**(前端在用它); +//! - **业务包 = 面 B**(`/api/shop/Product`)—— 官方 JNPF 形状, +//! 集成到官方 Java 时能直接搬。 //! -//! 🔴 本模块的守卫:菜单 `shop/Product`(`module_key`)⇒ 非管理员未授权 ⇒ `code=403`。 +//! 🔴 **DDL 跟着包走**:`shop_product` 的建表语句在 `packs/shop/schema/001_init.sql`, +//! 编译进二进制 ⇒ 不再手抄进 `db/schema.sql`。 +//! +//! 🔴 **本包是示例包**:`packs/shop` 整目录可搬去技能当样板,本文件是它在本仓的 +//! 面 A 适配器(技能带走示例时,这份适配器可以不要)。 use axum::body::Bytes; use axum::extract::{RawQuery, State}; @@ -15,84 +22,18 @@ use axum::http::HeaderMap; use axum::routing::{delete, get, post}; use axum::{Json, Router}; -use crate::platform::crud::{handle_delete, handle_list, handle_save}; -use crate::platform::entity::{ColumnSpec, EntitySpec}; -use crate::platform::envelope::ActionResult; -use crate::platform::menu::MenuSpec; -use crate::platform::state::AppState; +use sspf::crud::{handle_delete, handle_list, handle_save}; +use sspf::envelope::ActionResult; +use sspf::AppState; -/// `shop_product` 的列清单(**顺序 = 响应 JSON 的键序**)。 -const PRODUCT_COLUMNS: &[ColumnSpec] = &[ - ColumnSpec { - column: "f_id", - json_key: "id", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_title", - json_key: "title", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_price", - json_key: "price", - default: Some("0.00"), - numeric: true, - }, - ColumnSpec { - column: "f_creator_user_id", - json_key: "creatorUserId", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_creator_time", - json_key: "creatorTime", - default: None, - numeric: false, - }, - ColumnSpec { - column: "f_delete_mark", - json_key: "deleteMark", - default: Some("0"), - numeric: false, - }, -]; +// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。 +pub use sspf_pack_shop::PRODUCT_MENU; +pub use sspf_pack_shop::PRODUCT_SPEC; -/// `shop_product` 的 spec。 -pub const PRODUCT_SPEC: EntitySpec = EntitySpec { - app_code: "shop", - entity: "Product", - table: "shop_product", - module_key: Some("shop/Product"), - columns: PRODUCT_COLUMNS, - numeric_columns: &["f_price"], - // 🔴 裁决 S22:非 demo 表 ⇒ `body.creatorUserId || 'admin'`。 - creator_fixed: None, -}; - -/// 🔴 **本模块的内置菜单**(契约 §8.4)—— 业务知识 ⇒ 住在**业务层**。 +/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。 /// -/// 🔴 **`url_address` 必须与 [`PRODUCT_SPEC`] 的 `module_key` 一字不差** -/// (都是 `shop/Product`)—— 面 A 的菜单守卫靠它命中。 -pub const PRODUCT_MENU: MenuSpec = MenuSpec { - id: "m_product", - full_name: "产品管理", - // 🔴 **本仓自定的占位编码**(官方 JNPF 没有 shop 模块)⇒ 见 `docs/known-limitations.md` §H。 - en_code: "permission.shop.product", - url_address: "shop/Product", - parent_id: "0", - menu_type: 2, - icon: Some("app"), - sort_code: 7, -}; - -/// 本模块的 3 条路由(**业务层的路由表**)—— 钉子测试遍历它。 -/// -/// 🔴 **业务路由清单住在业务层** ⇒ 平台层(`routes.rs`)不认业务路径 -/// ⇒ 加业务模块**不用改平台层**(平台层的钉子测试遍历本表)。 +/// 🔴 路径写字面量(不用下标):`scripts/check-contract-scan.py` 是静态解析, +/// 认不出数组下标 ⇒ 写下标会让契约闸门判「登记了、代码里没有」。 pub const ROUTES: [&str; 3] = [ "/api/ssw/shop/Product/List", "/api/ssw/shop/Product/Save", @@ -125,7 +66,7 @@ pub async fn product_delete( handle_delete(&state, &headers, &PRODUCT_SPEC, &raw).await } -/// 本模块的路由(`Router::merge` 进总路由,**对齐 NestJS 的 module 注册**)。 +/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。 pub fn router() -> Router { Router::new() .route("/api/ssw/shop/Product/List", get(product_list)) diff --git a/src/backend/src/packs_gen.rs b/src/backend/src/packs_gen.rs new file mode 100644 index 0000000..8be30d7 --- /dev/null +++ b/src/backend/src/packs_gen.rs @@ -0,0 +1,167 @@ +//! ⚠️ **本文件由 `scripts/pack-sync.py` 生成 —— 不许手改。** +//! +//! 它是应用的**业务包清单**:每个包一条 [`sspf::load_static`] 调用 +//! + 一份 `pack.toml` 的 JSON 快照。 +//! +//! 🔴 **为什么是生成的**:手写这段要抄「manifest JSON + `PackSource` + `merge`」三段, +//! 漏掉 `merge` 的表现是:包**装载成功**、没有报错,但 `entities` / `routes` 全丢 +//! ⇒ **面 B 端点静默 404**。⇒ 改成生成 ⇒ 「漏一处」在机制上不存在; +//! 真忘了跑生成,`pack-sync.py --check` 会红。 +//! +//! 🔴 **`packs/` 是唯一真源** —— 加包跑 `bash scripts/new-pack.sh`, +//! 改完 `packs/*` 跑 `python3 scripts/pack-sync.py`。 +//! +//! 🔴 **本文件不认识平台**:包只依赖 `sspf` 门面;菜单 / DDL / 面 B 路由 +//! 由 `sspf::Platform::packs(reg)` 一并带进装配链(不用再单独 `.menus()`, +//! 给两次会在种子里撞主键)。 + +use sspf::{load_static, LoadError, PackRegistry}; + +/// 装载 `packs/*` 下的**全部**业务包(顺序 = `app_code` 字典序)。 +/// +/// 🔴 任一包装载失败 ⇒ **整体失败**(半加载的包比不加载更危险): +/// 半加载的包 = 一部分路由在、一部分不在 ⇒ 前端表现为「有的页面能用」。 +pub fn registry(kernel_version: &str) -> Result { + let mut regs: Vec = Vec::new(); + + // >>>GEN:PACKS + // ---- asset ---- + regs.push(load_static( + "asset", + ASSET_MANIFEST_JSON, + Box::new(sspf_pack_asset::Pack), + sspf_pack_asset::DDLS, + kernel_version, + )?); + + // ---- books ---- + regs.push(load_static( + "books", + BOOKS_MANIFEST_JSON, + Box::new(sspf_pack_books::Pack), + sspf_pack_books::DDLS, + kernel_version, + )?); + + // ---- demo ---- + regs.push(load_static( + "demo", + DEMO_MANIFEST_JSON, + Box::new(sspf_pack_demo::Pack), + sspf_pack_demo::DDLS, + kernel_version, + )?); + + // ---- shop ---- + regs.push(load_static( + "shop", + SHOP_MANIFEST_JSON, + Box::new(sspf_pack_shop::Pack), + sspf_pack_shop::DDLS, + kernel_version, + )?); +// <</pack.toml`(给人看、给导出工具读); +// 这里是它的**编译期 JSON 快照**。为什么快照、不运行期读文件: +// 部署是**单二进制** ⇒ 运行目录里不一定有 `packs/` 目录。 +// 两份的一致性由 `scripts/pack-sync.py` 保证(`--check` 会比对)。 + +// >>>GEN:MANIFESTS +/// `packs/asset/pack.toml` 的编译期快照。 +const ASSET_MANIFEST_JSON: &str = r#"{ + "pack": { + "app_code": "asset", + "name": "数据资源", + "version": "1.0.0", + "kernel": ">=0.4,<0.5", + "migratable": true, + "tables": [ + { + "name": "asset_data_resource", + "ddl": "schema/001_init.sql", + "baseline_table": "asset_data_resource" + } + ] + } +}"#; + +/// `packs/books/pack.toml` 的编译期快照。 +const BOOKS_MANIFEST_JSON: &str = r#"{ + "pack": { + "app_code": "books", + "name": "图书超市", + "version": "1.0.0", + "kernel": ">=0.4,<0.5", + "migratable": true, + "tables": [ + { + "name": "book_shop_book", + "ddl": "schema/001_init.sql", + "baseline_table": "book_shop_book" + } + ] + } +}"#; + +/// `packs/demo/pack.toml` 的编译期快照。 +const DEMO_MANIFEST_JSON: &str = r#"{ + "pack": { + "app_code": "demo", + "name": "Demo 示例", + "version": "1.0.0", + "kernel": ">=0.4,<0.5", + "migratable": true, + "tables": [ + { + "name": "demo_item", + "ddl": "schema/001_init.sql", + "baseline_table": "demo_item" + } + ] + } +}"#; + +/// `packs/shop/pack.toml` 的编译期快照。 +const SHOP_MANIFEST_JSON: &str = r#"{ + "pack": { + "app_code": "shop", + "name": "产品管理", + "version": "1.0.0", + "kernel": ">=0.4,<0.5", + "migratable": true, + "tables": [ + { + "name": "shop_product", + "ddl": "schema/001_init.sql", + "baseline_table": "shop_product" + } + ] + } +}"#; +// << = reg.manifests.keys().map(String::as_str).collect(); + assert_eq!(apps, ["asset", "books", "demo", "shop"]); + assert_eq!(reg.entities.len(), 4, "每个包一个实体 spec"); + assert_eq!(reg.ddls.len(), 4, "每个包一份 DDL"); + assert!(!reg.menus.is_empty(), "业务菜单要跟着包进来(面 B 守卫靠它)"); + } +} diff --git a/src/backend/src/platform/auth.rs b/src/backend/src/platform/auth.rs deleted file mode 100644 index 5d5e1bc..0000000 --- a/src/backend/src/platform/auth.rs +++ /dev/null @@ -1,264 +0,0 @@ -//! auth —— 登录(`/api/oauth/Login`)、当前用户(`/api/oauth/CurrentUser`)与两个请求守卫。 -//! -//! 契约:规格 §6.1(认证)+ §9(`auth.rs` 接口)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/auth/`。 -//! -//! 🔴 **三条硬约定**: -//! 1. **业务失败恒 HTTP 200**:登录失败 `code=400`、未登录 `code=600`、无菜单权限 `code=403` -//! —— 全都是**信封里的 code**,不是 HTTP 状态码(**别抄 `tdc-rs` 的裸 401/403**)。 -//! 2. **表单解析失败也要走业务信封**:axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` -//! ⇒ `Option>` 编译不过 ⇒ 登录端点取**原始 body** 自己解析, -//! 解析失败返回 `fail(400, "缺少 account / password")`,**不是** axum 默认的 400 文本。 -//! 3. **口令不得外泄**:请求体里的密文只在内存里比对,响应体里**永不**回显; -//! 库里存的是 `md5(明文)`(`base_user.f_password`)。 - -use axum::body::Bytes; -use axum::extract::State; -use axum::http::HeaderMap; -use axum::Json; -use serde_json::{json, Value}; - -use crate::platform::cipher::decrypt_to_md5; -use crate::platform::envelope::{fail, ok, ActionResult}; -use crate::platform::permission::{build_menu_list, has_module}; -use crate::platform::session::TokenUser; -use crate::platform::state::AppState; - -/// token 有效期(秒)—— 契约 §6.1:恒为 `7200`。 -const TOKEN_EXPIRES_IN: i64 = 7200; - -/// 登录成功体里的 `tokenTypeName` —— 契约 §6.1:恒为 `"bearer"`。 -const TOKEN_TYPE_NAME: &str = "bearer"; - -/// 登录表单(**form-urlencoded**)。 -/// -/// 🔴 三个字段全是 `Option`:缺字段也要走**业务信封**(`code=400`), -/// 不能落到 axum 默认的 400 文本。 -/// 🔴 `grant_type` 是 **snake_case 字面量**(协议规定),**不能**改成 camelCase。 -/// 🔴 **不派生 `Debug`**:本结构体携带**口令密文**,一次 `{:?}` 就把密文打进日志。 -#[derive(serde::Deserialize)] -pub struct LoginForm { - /// 登录账号。 - pub account: Option, - /// 口令**密文**(hex)。 - pub password: Option, - /// 授权类型(`password`;可缺省)。 - pub grant_type: Option, -} - -/// 登录(契约 §6.1)。 -/// -/// 校验顺序(**不可换**,规格 §6.1 + brief S14): -/// 1. `account` 或 `password` 为空 ⇒ `fail(400, "缺少 account / password")`; -/// 2. `grant_type` **非空**且 ≠ `password` ⇒ `fail(400, "不支持的 grant_type")`; -/// 3. 账号不存在 / 已软删 / 口令不等 / **密文非法** ⇒ `fail(400, "账号或密码错误")`。 -/// -/// 🔴 密文非法(`decrypt_to_md5` 返回 `None`)与「口令错」是**同一条消息** -/// (react 的 `decryptToMd5` 失败返空串 ⇒ 比对不等 ⇒ 同一分支)⇒ 不另造文案。 -/// -/// 🔴 口令比对**大小写不敏感**(两边都转小写再比)。 -/// 🔴 查用户**只比未软删的行**(`f_delete_mark = 0`)。 -pub async fn login(state: &AppState, body: LoginForm) -> Json { - let account = body.account.unwrap_or_default(); - let encrypted = body.password.unwrap_or_default(); - - // ---- 序 1:缺 account / password ---- - if account.is_empty() || encrypted.is_empty() { - return fail(400, "缺少 account / password"); - } - - // ---- 序 2:grant_type 不支持 ---- - // 🔴 `grant_type` **缺失是允许的**;空串按「未设置」处理(与 react 的 falsy 判定一致)。 - if let Some(grant_type) = body.grant_type.as_deref() { - if !grant_type.is_empty() && grant_type != "password" { - return fail(400, "不支持的 grant_type"); - } - } - - // ---- 序 3:查用户(只比未软删的)---- - let rows = match state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"storedPassword\", \ - f_is_administrator AS \"isAdministrator\" \ - FROM base_user WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&account], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - // 🔴 契约 §R1.2 / §6.5:DB 报错 ⇒ `系统异常,请联系管理员` - // (**不是**「账号或密码错误」—— DB 挂了不该伪装成口令错: - // 用户会反复重试,运维也看不到告警信号;两条消息必须能区分)。 - // 真因只进服务端日志,**不外泄**。 - eprintln!("[auth] 查询用户失败: {e}"); - return fail(400, "系统异常,请联系管理员"); - } - }; - - let Some(row) = rows.first() else { - // 账号不存在(或已软删)。 - return fail(400, "账号或密码错误"); - }; - - // 库内存的是 `md5(明文)`;密文解出来也是 `md5(明文)` ⇒ 直接比。 - // 🔴 `f_password` 可能是 NULL(官方 DDL 允许)⇒ 视为不匹配。 - // 🔴 JSON 键叫 `storedPassword`(**不叫 `password`**):免得有人一次 - // `println!("{row:?}")` 就把口令哈希打进日志。 - let stored = row.get("storedPassword").and_then(Value::as_str).unwrap_or(""); - let plain_md5 = match decrypt_to_md5(&encrypted) { - Some(md5) => md5, - // 🔴 密文非法(非法 hex / 非法 PKCS7 填充)⇒ **同一条**「账号或密码错误」。 - None => return fail(400, "账号或密码错误"), - }; - if stored.is_empty() || stored.to_lowercase() != plain_md5.to_lowercase() { - return fail(400, "账号或密码错误"); - } - - let user_id = row.get("id").and_then(Value::as_str).unwrap_or("").to_string(); - let account = row - .get("account") - .and_then(Value::as_str) - .unwrap_or(account.as_str()) - .to_string(); - let is_admin = row - .get("isAdministrator") - .and_then(Value::as_i64) - .and_then(|v| i32::try_from(v).ok()) - .unwrap_or(0); - - let token = state.sessions.issue(&account, &user_id, is_admin); - ok(json!({ - "token": token, - "expiresIn": TOKEN_EXPIRES_IN, - "tokenTypeName": TOKEN_TYPE_NAME, - })) -} - -/// 登录端点的**原始 body** 版本(契约 §6.1 的实现注记)。 -/// -/// 🔴 axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` ⇒ `Option>` 编译不过 -/// ⇒ 这里自己用 `serde_urlencoded` 解析。 -/// 🔴 **解析失败也走业务信封**(`fail(400, "缺少 account / password")`), -/// 绝不能让 axum 返默认的 400 文本(前端拿到的是 HTML/纯文本,不是 `{code,msg,data}`)。 -pub async fn login_from_bytes(state: &AppState, body: Bytes) -> Json { - let form = match serde_urlencoded::from_bytes::(&body) { - Ok(form) => form, - Err(_) => return fail(400, "缺少 account / password"), - }; - login(state, form).await -} - -/// axum handler(`POST /api/oauth/Login`)—— Task 10 装配路由时直接用它。 -pub async fn login_handler(State(state): State, body: Bytes) -> Json { - login_from_bytes(&state, body).await -} - -/// 当前用户(契约 §6.1)。 -/// -/// - 未登录 ⇒ `fail(600, "未登录")`; -/// - 成功 ⇒ `data = {"userInfo": {...}, "menuList": [...]}`。 -/// -/// 🔴 `userName` = **账号**(不是 `realName`);`isAdministrator` 是 **JSON 布尔**。 -/// -/// 🔴 **面 B 分流**:请求头带 `Vue-Version: 3` ⇒ 走**官方 `PcUserVO` 形状** -/// (`JNPF_COMPAT_SURFACE.md` §3.1)⇒ **面 A 的形状一个字都不动**。 -pub async fn current_user(state: &AppState, headers: HeaderMap) -> Json { - // 🔴 判别头 = `Vue-Version: 3`(本仓前端唯一不发的官方头 ⇒ 零歧义)。 - if crate::platform::jnpf::is_jnpf(&headers) { - return crate::platform::jnpf::current_user(state, &headers).await; - } - - let Some(user) = resolve_user(state, &headers) else { - return fail(600, "未登录"); - }; - - let menu_list = build_menu_list(&state.db, &user.user_id, user.is_admin).await; - - ok(json!({ - "userInfo": { - "userId": user.user_id, - "userAccount": user.account, - "userName": user.account, - "isAdministrator": user.is_admin == 1, - }, - "menuList": menu_list, - })) -} - -/// 守卫:**未登录** ⇒ `Err(fail(600, "未登录"))`;已登录 ⇒ `Ok(TokenUser)`。 -/// -/// 🔴 失败也是 **HTTP 200** + `code=600`(不是 401)。 -pub async fn require_login( - state: &AppState, - headers: &HeaderMap, -) -> Result> { - match resolve_user(state, headers) { - Some(user) => Ok(user), - None => Err(fail(600, "未登录")), - } -} - -/// 守卫(**面 B**):**未登录 / token 无效** ⇒ `Err(fail(602, …))`;已登录 ⇒ `Ok(TokenUser)`。 -/// -/// 🔴 **面 B 必须返 `602` 而不是 `600`** —— 官方前端 `request.ts:78-80` 只对 -/// `601`/`602`(`TOKEN_ERROR` / `TOKEN_LOGGED` / `TOKEN_TIMEOUT`)清 token -/// ⇒ 只返 `600` 会让页面**卡住不跳登录**(`JNPF_COMPAT_SURFACE.md` §4)。 -/// -/// 🔴 失败也**恒 HTTP 200**(信封里的 `code`),不是 HTTP 401。 -pub async fn require_login_jnpf( - state: &AppState, - headers: &HeaderMap, -) -> Result> { - match resolve_user(state, headers) { - Some(user) => Ok(user), - None => Err(fail( - crate::platform::envelope::code::SESSION_ERROR, - "登录状态已失效,请重新登录", - )), - } -} - -/// 守卫(**按面分流**):面 B(`Vue-Version: 3`)⇒ `602`;面 A ⇒ `600`。 -/// -/// 🔴 用在**两个面共用的路由**上(如 `PUT /api/permission/Authority/Data/{objectId}`): -/// 同一个「未登录」场景,**面 A 返 600、面 B 返 602**。 -pub async fn require_login_any( - state: &AppState, - headers: &HeaderMap, -) -> Result> { - if crate::platform::jnpf::is_jnpf(headers) { - require_login_jnpf(state, headers).await - } else { - require_login(state, headers).await - } -} - -/// 守卫:**登录 + 菜单权限**。 -/// -/// 1. 先 `require_login`(未登录 ⇒ `600`); -/// 2. 再 `has_module(...)`;无权限 ⇒ `Err(fail(403, "无菜单权限"))`。 -/// -/// 🔴 失败也是 **HTTP 200** + `code=403`(不是 403 状态码)。 -pub async fn require_module( - state: &AppState, - headers: &HeaderMap, - module_key: &str, -) -> Result> { - let user = require_login(state, headers).await?; - if has_module(&state.db, &user.user_id, user.is_admin, module_key).await { - Ok(user) - } else { - Err(fail(403, "无菜单权限")) - } -} - -/// 从 `Authorization` 头解析出当前用户(无 / 非法 ⇒ `None`)。 -/// -/// 🔴 `pub(crate)` —— 面 B 的 `jnpf` 模块也要用它(官方形状的 `CurrentUser`)。 -pub(crate) fn resolve_user(state: &AppState, headers: &HeaderMap) -> Option { - let auth = headers.get("authorization")?; - let auth = auth.to_str().ok()?; - state.sessions.resolve(Some(auth)) -} diff --git a/src/backend/src/platform/cipher.rs b/src/backend/src/platform/cipher.rs deleted file mode 100644 index 01ccf43..0000000 --- a/src/backend/src/platform/cipher.rs +++ /dev/null @@ -1,213 +0,0 @@ -//! cipher —— md5 + AES-256-ECB(与 react 版 cipher.ts 逐字节等价)。 -//! -//! 对齐物:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/common/cipher.ts` -//! -//! 契约(**不得改动**,见 `.superpowers/sdd/ssw-jnpf-lite-rust-v1/task-1-brief.md`): -//! 1. `key = md5_hex("EY8WePvjM5GGwQzn")` —— 把这 **32 个 ASCII 字节**当 key ⇒ **AES-256** -//! (⚠️ 不是 16 字节原始摘要;用 16 字节会退化成 AES-128 ⇒ 所有登录全挂) -//! 2. `src = md5_hex(plaintext)` 的 **32 个 ASCII 字节** -//! 3. `AES-256-ECB-PKCS7`,输出 hex(32 字节明文 ⇒ PKCS7 补满一整块 ⇒ 48 字节密文 ⇒ 96 个 hex 字符) -//! -//! 🔴 **口令不得外泄**:本模块的输出只在**请求体**里出现(登录时前端传来的密文), -//! 永不在响应里回显。库里存的是 `md5(明文)`(`base_user.f_password`)。 - -use aes::cipher::{ - block_padding::Pkcs7, generic_array::GenericArray, BlockDecryptMut, BlockEncryptMut, KeyInit, -}; -use md5::{Digest, Md5}; - -/// AES-256-ECB 加密器(cipher 0.4 家族:`BlockEncryptMut` + `Pkcs7`)。 -type Aes256EcbEnc = ecb::Encryptor; -/// AES-256-ECB 解密器。 -type Aes256EcbDec = ecb::Decryptor; - -/// react 版 cipher.ts 里的 `CIPHER_KEY`。 -const CIPHER_KEY: &str = "EY8WePvjM5GGwQzn"; - -/// AES 分组长度(字节)。 -const BLOCK_SIZE: usize = 16; - -/// `md5(明文)` 的十六进制串(32 个字符)。 -/// -/// 与 react 版 `md5Hex` 等价:CryptoJS.MD5(str).toString() ⇒ 小写 hex。 -pub fn md5_hex(s: &str) -> String { - hex::encode(Md5::digest(s.as_bytes())) -} - -/// 派生出 AES-256 key:**32 个 ASCII 字节**(即 `md5_hex(CIPHER_KEY)` 这个 32 字符 hex 串本身)。 -fn cipher_key_bytes() -> [u8; 32] { - let key = md5_hex(CIPHER_KEY); - // `md5_hex` 恒为 32 个 ASCII 字符 ⇒ 长度必然是 32。 - let bytes = key.into_bytes(); - let mut out = [0u8; 32]; - out.copy_from_slice(&bytes); - out -} - -/// 登录密码加密:`md5(明文)` → AES-256-ECB-PKCS7 → hex。 -/// -/// 上游检验向量:`encrypt_password("123456")` == -/// `d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b` -/// (96 个 hex 字符 = 48 字节密文;**不是** 64 —— 漏了 PKCS7 填充就会输出 64)。 -pub fn encrypt_password(plain: &str) -> String { - // src = md5(明文) 的 32 个 ASCII 字节。 - let src = md5_hex(plain).into_bytes(); - debug_assert_eq!(src.len(), 32, "md5_hex 恒为 32 个 ASCII 字符"); - - // 32 字节明文 + PKCS7 补满一整块 ⇒ 48 字节密文。 - let mut buf = [0u8; 48]; - buf[..src.len()].copy_from_slice(&src); - - let key_bytes = cipher_key_bytes(); - // 🔴 `KeyInit::new` 是 cipher 0.4 的**不可失败**构造器(`new_from_slice` 内部 - // 就是 `Self::new(Key::from_slice(key))`,两者完全等价)⇒ 去掉 `expect`。 - let key = GenericArray::clone_from_slice(&key_bytes); - let enc = Aes256EcbEnc::new(&key); - let ct = match enc.encrypt_padded_mut::(&mut buf, src.len()) { - Ok(ct) => ct, - Err(_) => { - // 🔴 理论不可达:buf 48 字节、msg 32 字节,PKCS7 最多补 16 字节 ⇒ 放得下。 - // 真到了这里就 **fail closed**(返空串 ⇒ 下游 `decrypt_to_md5` 返 `None` - // ⇒ 登录走「账号或密码错误」),**绝不 panic**(panic 会打断 HTTP 连接)。 - // 🔴 **绝不回显明文/密文**(那是口令泄漏)。 - eprintln!("[cipher] PKCS7 填充失败(理论不可达)"); - return String::new(); - } - }; - hex::encode(ct) -} - -/// 解密前端加密串 → `md5(明文)`,用于登录比对。 -/// -/// 非法 hex / 长度不是分组整数倍 / PKCS7 填充不合法 ⇒ `None`。 -pub fn decrypt_to_md5(encrypted_hex: &str) -> Option { - let mut ct = hex::decode(encrypted_hex).ok()?; - if ct.is_empty() || ct.len() % BLOCK_SIZE != 0 { - return None; - } - - let key = cipher_key_bytes(); - let dec = Aes256EcbDec::new_from_slice(&key).ok()?; - let pt = dec.decrypt_padded_mut::(&mut ct).ok()?; - String::from_utf8(pt.to_vec()).ok() -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 上游(react 版 cipher.ts)检验向量 —— 逐字节相等才算通过。 - #[test] - fn encrypt_password_matches_upstream_vector() { - assert_eq!( - encrypt_password("123456"), - "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" - ); - } - - /// 上游检验向量反向:上游密文解出来必须等于 `md5("123456")`。 - #[test] - fn decrypt_matches_upstream_vector() { - assert_eq!( - decrypt_to_md5( - "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" - ), - Some(md5_hex("123456")) - ); - assert_eq!( - decrypt_to_md5( - "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" - ), - Some("e10adc3949ba59abbe56e057f20f883e".to_string()) - ); - } - - /// 十六进制大小写都接受(前端 CryptoJS `Hex.parse` 产出小写,但别把大小写当契约)。 - #[test] - fn uppercase_hex_input_is_accepted() { - let lower = encrypt_password("123456"); - let upper = lower.to_uppercase(); - assert_ne!(lower, upper, "输入必须真的变成大写,否则这条断言是空转"); - assert_eq!(decrypt_to_md5(&upper), Some(md5_hex("123456"))); - } - - #[test] - fn md5_hex_of_empty_string() { - assert_eq!(md5_hex(""), "d41d8cd98f00b204e9800998ecf8427e"); - } - - #[test] - fn md5_hex_of_abc() { - assert_eq!(md5_hex("abc"), "900150983cd24fb0d6963f7d28e17f72"); - } - - #[test] - fn round_trip_returns_md5_of_plaintext() { - assert_eq!( - decrypt_to_md5(&encrypt_password("hunter2")), - Some(md5_hex("hunter2")) - ); - } - - #[test] - fn invalid_hex_yields_none() { - assert_eq!(decrypt_to_md5("not-hex!!"), None); - assert_eq!(decrypt_to_md5("zz"), None); - } - - /// 32 字节明文 ⇒ PKCS7 补满一整块 ⇒ 48 字节密文 ⇒ 96 个 hex 字符。 - #[test] - fn ciphertext_length_is_96_hex_chars() { - assert_eq!(encrypt_password("x").len(), 96); - // 空明文同样走 32 字节 md5,长度不变。 - assert_eq!(encrypt_password("").len(), 96); - } - - /// key 必须是 md5_hex(CIPHER_KEY) 的 **32 个 ASCII 字节** ⇒ AES-256,不是 AES-128。 - #[test] - fn key_is_32_ascii_bytes() { - let key = cipher_key_bytes(); - assert_eq!(key.len(), 32); - assert_eq!(std::str::from_utf8(&key).unwrap(), md5_hex(CIPHER_KEY)); - // 32 字节 key ⇒ AES-256(KeySize = U32)。 - assert!(Aes256EcbEnc::new_from_slice(&key).is_ok()); - } - - /// 长度不是分组整数倍 ⇒ None(解不开)。 - #[test] - fn wrong_length_ciphertext_yields_none() { - assert_eq!(decrypt_to_md5("00"), None); - assert_eq!(decrypt_to_md5(""), None); - } - - /// 规格 §3:**PKCS7 填充不合法 ⇒ `None`**(钉住 `block-padding 0.3.3` 的严格解填充)。 - /// - /// `block-padding-0.3.3/src/lib.rs:216-218` 的 `Pkcs7::raw_unpad` 传 `strict = true` - /// ⇒ 填充字节不全等于长度字节 n 时解填充失败 ⇒ `None`。 - /// - /// 构造(确定性,不靠概率):上游向量是 48 字节密文 = 32 字节明文 + **整块 16 字节填充** - /// ⇒ 最后一个密文块解出来是 16 个 `0x10`。ECB 无扩散 ⇒ 改**密文**的某字节, - /// 只改对应明文字节。 - #[test] - fn invalid_pkcs7_padding_yields_none() { - let good = encrypt_password("123456"); - let bytes = hex::decode(&good).unwrap(); - assert_eq!(bytes.len(), 48, "32 字节明文 + 整块 16 字节填充"); - - // ① 改填充块的**长度字节**(末字节):0x10 → 0x11(= 17 > 块长 16)⇒ 填充非法。 - let mut a = bytes.clone(); - a[47] ^= 0x01; - let corrupted_len_byte = hex::encode(&a); - assert_ne!(corrupted_len_byte, good); - assert_eq!(decrypt_to_md5(&corrupted_len_byte), None); - - // ② 改填充块**中间某个填充字节**(第 2 个):0x10 → 0x0f。 - // 长度字节仍是 0x10(= 16,合法范围),但填充字节不自洽 - // ⇒ **严格模式**才拒;宽松模式会照单全收 ⇒ 这条断言正是「严格性」的证据。 - let mut b = bytes.clone(); - b[32 + 1] = 0x0f; - let corrupted_fill_byte = hex::encode(&b); - assert_ne!(corrupted_fill_byte, good); - assert_eq!(decrypt_to_md5(&corrupted_fill_byte), None); - } -} diff --git a/src/backend/src/platform/config.rs b/src/backend/src/platform/config.rs deleted file mode 100644 index 6bfbcd7..0000000 --- a/src/backend/src/platform/config.rs +++ /dev/null @@ -1,160 +0,0 @@ -//! config —— 环境变量与路径解析(PORT / PGLITE_DIR / 静态目录)。 -//! -//! 契约:`docs/contract.md` §9「config.rs」。 -//! -//! 路径口径: -//! - `project_dir` = 项目根(由 `main.rs` 从可执行文件向上定位锚点文件得到)。 -//! - `pg_dir` 默认 `/src/backend/data/lite.pg`(pglite 数据目录)。 -//! - `static_dir` = `/src/frontend/dist`,**不存在则 None**(前端产物没编译出来时 -//! 不该让后端去托管一个不存在的目录)。 - -use std::net::{IpAddr, Ipv4Addr}; -use std::path::{Path, PathBuf}; - -use crate::platform::guard::Profile; - -/// 后端默认端口。 -/// -/// 🔴 本仓固定 `:30010`;兄弟项目 `tdc-rs` 占 `:30000`,两者**不共享**任何东西。 -pub const DEFAULT_PORT: u16 = 30010; - -/// 后端**默认监听地址** = `127.0.0.1`(**只监听本机**)。 -/// -/// 🔴 默认值朝**安全方向**:本仓的种子口令是 `admin/123456`、token 永不过期 -/// ⇒ 若默认监听所有网卡,局域网内可直接连上后端 ⇒ 必须默认只绑本机。 -/// 要在容器 / 反代里对外暴露 ⇒ 显式设 `BIND_ADDR=0.0.0.0`。 -pub const DEFAULT_BIND_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)); - -/// `PGLITE_DIR` 设成该值 ⇒ 用**临时库**(进程退出即销毁)。 -/// -/// pglite-rs 0.2.7 **没有** 真内存模式(`memory://` 不是它的协议), -/// 所以「临时库」= `PGlite::open_temp()` = 系统临时目录里的一个一次性数据目录。 -pub const TEMP_DIR_MARKER: &str = "memory://"; - -/// 🔴 **种子 admin 的缺省口令**(契约 §8.6 逐字要求 `admin/123456`)。 -/// -/// 🔴 **这不是「忘了改」的常量,而是契约的一部分** ⇒ 缺省值**不可改**, -/// 生产档要换口令走 `SEED_ADMIN_PASSWORD` env(见 [`Config::seed_admin_password`])。 -pub const DEFAULT_SEED_ADMIN_PASSWORD: &str = "123456"; - -/// 运行时配置(全部来自环境变量 + 项目目录推导)。 -#[derive(Clone, Debug)] -pub struct Config { - /// HTTP 监听端口(env `PORT`,缺省或非法 ⇒ `30010`)。 - pub port: u16, - /// HTTP 监听地址(env `BIND_ADDR`,缺省或非法 ⇒ `127.0.0.1`)。 - /// - /// 🔴 **只接受字面 IP**(`127.0.0.1` / `0.0.0.0` / `::1`)⇒ **不解析主机名** - /// (`localhost` 会被判非法 ⇒ 回落 `127.0.0.1`,即朝安全方向回落)。 - pub bind_addr: IpAddr, - /// pglite 数据目录(env `PGLITE_DIR`;值为 `memory://` ⇒ 临时库)。 - pub pg_dir: PathBuf, - /// 项目根目录。 - pub project_dir: PathBuf, - /// 前端产物目录 `/src/frontend/dist`;不存在 ⇒ `None`。 - pub static_dir: Option, - /// 部署档位(env `SSW_PROFILE`;缺省或非法 ⇒ [`Profile::Dev`])。 - /// - /// 🔴 **缺省 = `Dev`** ⇒ 弱口令守卫**不生效** ⇒ 本地开发与冒烟脚本**零影响**。 - pub profile: Profile, - /// 种子 admin 的口令(env `SEED_ADMIN_PASSWORD`;缺省 ⇒ [`DEFAULT_SEED_ADMIN_PASSWORD`])。 - /// - /// 🔴 **只在空库首启时生效**(`first_seed` 仅当 `base_user` 行为 0 时跑) - /// ⇒ 已有库里 admin 的口令**改这个 env 不会变**(要在管理界面改)。 - pub seed_admin_password: String, -} - -impl Config { - /// 从环境变量 + 传入的 `project_dir` 组装配置。 - /// - /// - `PORT`:非法值**不 panic**,回落 `30010`(配置写错不该让服务起不来)。 - /// - `BIND_ADDR`:非法值**不 panic**,回落 `127.0.0.1`(**朝安全方向**回落, - /// 与 `PORT` 非法回落 `30010` 同一政策);**只接受字面 IP**,不解析主机名。 - /// - `PGLITE_DIR`:空串按「未设置」处理 ⇒ 用默认数据目录。 - /// - `SSW_PROFILE`:非法值**回落 `Dev`**(不误伤本地开发)。 - /// - `SEED_ADMIN_PASSWORD`:空串按「未设置」处理 ⇒ 用契约缺省 `123456`。 - pub fn from_env(project_dir: PathBuf) -> Config { - let port = std::env::var("PORT") - .ok() - .and_then(|v| v.trim().parse::().ok()) - .unwrap_or(DEFAULT_PORT); - - let bind_addr = std::env::var("BIND_ADDR") - .ok() - .and_then(|v| v.trim().parse::().ok()) - .unwrap_or(DEFAULT_BIND_ADDR); - - let pg_dir = match std::env::var("PGLITE_DIR") { - Ok(v) if !v.trim().is_empty() => PathBuf::from(v.trim()), - _ => project_dir.join("src/backend/data/lite.pg"), - }; - - let dist = project_dir.join("src/frontend/dist"); - let static_dir = if dist.is_dir() { Some(dist) } else { None }; - - let profile = Profile::from_env_str(&std::env::var("SSW_PROFILE").unwrap_or_default()); - - let seed_admin_password = match std::env::var("SEED_ADMIN_PASSWORD") { - Ok(v) if !v.trim().is_empty() => v, - _ => DEFAULT_SEED_ADMIN_PASSWORD.to_string(), - }; - - Config { - port, - bind_addr, - pg_dir, - project_dir, - static_dir, - profile, - seed_admin_password, - } - } - - /// `pg_dir` 是否为「临时库」标记(`memory://`)⇒ 调用方应走 `Db::open_temp()`。 - pub fn pg_is_temp(&self) -> bool { - self.pg_dir.as_path() == Path::new(TEMP_DIR_MARKER) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn defaults_without_env() { - // 外部若已设置 PORT / PGLITE_DIR,本断言的前提不成立 ⇒ 跳过(不改动进程环境)。 - if std::env::var("PORT").is_ok() || std::env::var("PGLITE_DIR").is_ok() { - return; - } - // 默认端口恒为 30010,默认数据目录恒是 /src/backend/data/lite.pg。 - assert_eq!(DEFAULT_PORT, 30010); - let dir = PathBuf::from("/tmp/does-not-exist-project"); - let cfg = Config::from_env(dir.clone()); - assert_eq!(cfg.port, DEFAULT_PORT); - assert_eq!(cfg.pg_dir, dir.join("src/backend/data/lite.pg")); - assert_eq!(cfg.project_dir, dir); - // src/frontend/dist 不存在 ⇒ None - assert!(cfg.static_dir.is_none()); - } - - #[test] - fn bind_addr_defaults_to_loopback() { - // 外部若已设置 BIND_ADDR,本断言的前提不成立 ⇒ 跳过(不改动进程环境)。 - if std::env::var("BIND_ADDR").is_ok() { - return; - } - // 未设 BIND_ADDR ⇒ 只监听本机(朝安全方向回落;与 PORT 非法回落 30010 同一政策)。 - assert_eq!(DEFAULT_BIND_ADDR, IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))); - let cfg = Config::from_env(PathBuf::from("/tmp/does-not-exist-project")); - assert_eq!(cfg.bind_addr, DEFAULT_BIND_ADDR); - assert!(cfg.bind_addr.is_loopback()); - } - - #[test] - fn pg_is_temp_detects_marker() { - let mut cfg = Config::from_env(PathBuf::from("/tmp/x")); - assert!(!cfg.pg_is_temp()); - cfg.pg_dir = PathBuf::from(TEMP_DIR_MARKER); - assert!(cfg.pg_is_temp()); - } -} diff --git a/src/backend/src/platform/crud.rs b/src/backend/src/platform/crud.rs deleted file mode 100644 index 44e6b95..0000000 --- a/src/backend/src/platform/crud.rs +++ /dev/null @@ -1,607 +0,0 @@ -//! crud —— spec 驱动的通用 CRUD 引擎(**平台层**:不含任何业务 spec / 表名 / app_code)。 -//! -//! 🔴 **业务侧([`crate::modules`])把 [`EntitySpec`](crate::platform::entity::EntitySpec) -//! 声明进来,本引擎负责把 spec 变成 SQL**——加一张新业务表**不用改本文件**。 -//! -//! 契约:`docs/contract.md` §5.3(投影列集)+ §6.4(端点)+ §7.6(业务模块语义) -//! 与 §9(`crud.rs` 接口)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/{demo,shop,books}/` -//! 里的 `*.service.ts`(**逐条对齐**)。 -//! -//! 🔴 **七条硬约定**: -//! 1. **业务失败恒 HTTP 200**(信封里的 `code`);DB 报错 ⇒ `系统异常,请联系管理员` -//! (真因只进服务端日志,**不外泄**)。 -//! 2. **不得 `SELECT *`**:每列显式 `AS ""`(**带双引号** —— PG 会把未加引号的 -//! 标识符折叠成小写 ⇒ `row_to_json` 出来的键会变成 `price` 之外的大小写形态 ⇒ 前端读不到, -//! 且**静默**)。 -//! 3. **numeric 列必须投影成字符串**(`f_price::text AS "price"` ⇒ `"9.90"`); -//! `int` 列保持数字(`f_stock` ⇒ `100`)。 -//! 4. **标识符白名单 + 参数化**:表名 / 列名先过 `db::valid_table` / `db::valid_column`; -//! **所有值**走绑定参数,绝不拼进 SQL 文本。 -//! 5. **不用 axum 的 `Json` / `Query`**(前者 422、后者 400 ⇒ 非信封 body ⇒ 契约破) -//! ⇒ 取 `Bytes` / `RawQuery` 自己解析。 -//! 6. **只写 body 里出现的键**(react 的 `Object.assign` / TypeORM 的 `undefined` 语义)。 -//! 7. **非测试代码零 `unwrap()` / `expect()` / `panic!()`**。 -//! -//! 🔴 **Save 的三条路径(顺序不可换,裁决 S20 / S21 / S22)**: -//! | 路径 | 条件 | 写入内容 | -//! |---|---|---| -//! | 1 | body 里**无 id** | 新 uuid + now + `f_delete_mark=0` + spec 的 `default` | -//! | 2 | body 有 id、**库里查不到** | **只用该 id 新建**;body 没给的列**不写** | -//! | 3 | body 有 id、**库里查得到** | 覆盖更新(只覆盖 body 里出现的列) | -//! -//! 🔴 **路径 1 与路径 2 的默认值完全不同**:路径 1 用 spec 的 `default`(`'草稿'` / `'0.00'`), -//! 路径 2 **一个默认值都不加**(`f_stock` / `f_delete_mark` 由 DDL 的 `DEFAULT 0` 补出)。 -//! -//! 🔴 **空 body 的处理是「有意偏离」**:**0 字节 body** ⇒ JSON 解析失败 ⇒ -//! `请求参数格式错误`(HTTP 200 + 信封);而 JSON 数组 / 数字 / 字符串被当作**空对象** ⇒ 走路径 1 建行。 -//! react 侧 express body-parser 对空 body 给 `{}` ⇒ 建行 —— 本仓**有意不跟随**, -//! 依据是契约的通用规则「非法 JSON ⇒ 请求参数格式错误」;契约未覆盖 0 字节 body。 - -use axum::body::Bytes; -use axum::extract::RawQuery; -use axum::http::HeaderMap; -use axum::Json; -use serde_json::{Map, Value}; - -use crate::platform::auth::{require_login, require_module}; -use crate::platform::db::{self, pglite, pglite::ToSql, Db}; -use crate::platform::envelope::{fail, ok, ActionResult}; -use crate::platform::entity::{ColumnSpec, EntitySpec}; -use crate::platform::ids::new_uuid; -use crate::platform::session::TokenUser; -use crate::platform::state::AppState; - -/// `f_creator_user_id` 的兜底账号(**账号字符串,不是 uuid**)。 -/// -/// 🔴 `seed.rs` 里也有个同值常量,但那是**私有**的 ⇒ 这里定义自己的(裁决 S18)。 -const ADMIN_ACCOUNT: &str = "admin"; - -// 🔴 **平台层不认 app_code**:哪张表用「`f_creator_user_id` 写死」这条规则,是**业务知识** -// ⇒ 由业务 spec 的 `creator_fixed` 声明(`crate::modules::demo` 声明 `Some("admin")`), -// 引擎只读声明 ⇒ 加新业务表**不用改本文件**(裁决 S22)。 - -// ---------------------------------------------------------------- 通用小工具 - -/// DB 报错 ⇒ 统一文案(契约 §R1.2 / §6.5)。 -fn db_error(e: pglite::Error, ctx: &str) -> Json { - eprintln!("[crud] {ctx}失败: {e}"); - fail(400, "系统异常,请联系管理员") -} - -/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 -fn now_str() -> String { - chrono::Utc::now() - .naive_utc() - .format("%Y-%m-%d %H:%M:%S") - .to_string() -} - -/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 -/// -/// 🔴 `Option: ToSql` ⇒ `None` 会被编码成 SQL `NULL`(不是空串)。 -fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { - values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() -} - -/// body 值 ⇒ 文本(`null` / 对象 / 数组 ⇒ `None` ⇒ 写 NULL)。 -fn value_to_text(v: Option<&Value>) -> Option { - match v { - Some(Value::String(s)) => Some(s.clone()), - Some(Value::Number(n)) => Some(n.to_string()), - Some(Value::Bool(b)) => Some(b.to_string()), - _ => None, - } -} - -/// body 值 ⇒ 文本,但**按 JS 真值判定**(`||` 语义): -/// 空串 / `null` / 数字 `0` / `false` ⇒ `None`(falsy);其余 ⇒ 文本。 -/// -/// 🔴 用于 `body.creatorUserId || 'admin'`(react 的写法)—— 注意它与 -/// `??`([`value_to_text`] + 显式 null 回落)**不是一回事**。 -fn js_truthy_text(v: Option<&Value>) -> Option { - match v { - Some(Value::String(s)) if s.is_empty() => None, - Some(Value::String(s)) => Some(s.clone()), - Some(Value::Number(n)) => { - if n.as_f64().map(|f| f == 0.0).unwrap_or(false) { - None - } else { - Some(n.to_string()) - } - } - Some(Value::Bool(true)) => Some("true".to_string()), - _ => None, - } -} - -/// body 里的 `id` ⇒ `Some(id 文本)`(有 id)/ `None`(无 id)。 -/// -/// 🔴 与 `sys.rs::body_id` **完全一致**(裁决 S20): -/// - 键不存在 / `null` / 空串 ⇒ **无 id**(路径 1); -/// - 非空字符串 ⇒ **有 id**; -/// - 其它类型(数字 / 布尔)⇒ **有 id**(按其 JSON 文本去查)。 -fn body_id(obj: &Map) -> Option { - match obj.get("id") { - None | Some(Value::Null) => None, - Some(Value::String(s)) if s.is_empty() => None, - Some(Value::String(s)) => Some(s.clone()), - Some(other) => Some(other.to_string()), - } -} - -/// 取 query 参数;**缺失 / 解析失败 ⇒ 空串**(视作「参数缺失」)。 -/// -/// 🔴 **不用 axum 的 `Query`**:解析失败会返回 400 + 非信封 body ⇒ 契约破。 -fn query_param(raw: &RawQuery, key: &str) -> String { - let Some(q) = raw.0.as_deref() else { - return String::new(); - }; - let pairs: Vec<(String, String)> = serde_urlencoded::from_str(q).unwrap_or_default(); - pairs - .into_iter() - .find(|(k, _)| k == key) - .map(|(_, v)| v) - .unwrap_or_default() -} - -/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`(裁决 P61)。 -fn parse_body(body: &Bytes) -> Result, Json> { - match serde_json::from_slice::(body) { - Ok(Value::Object(m)) => Ok(m), - // 🔴 **不是对象**(数组 / 数字 / 字符串)⇒ 当作空对象(⇒ 走「参数缺失」分支)。 - Ok(_) => Ok(Map::new()), - Err(_) => Err(fail(400, "请求参数格式错误")), - } -} - -// ---------------------------------------------------------------- spec → SQL - -/// spec 的一列的 JSON 键(**校验它与契约的映射一致**)。 -/// -/// 🔴 `json_key` 写错 ⇒ 投影别名与 body 键**同时**对不上 ⇒ 前端读不到字段,且**静默**。 -fn json_key_of(col: &ColumnSpec) -> Result { - let expect = db::column_to_json_key(col.column); - if expect != col.json_key { - return Err(pglite::Error::Protocol(format!( - "spec 的 json_key 不对: {} 应为 {}(实际 {})", - col.column, expect, col.json_key - ))); - } - Ok(col.json_key.to_string()) -} - -/// 写入口的类型转换后缀(追加在 `::text` 之后)。 -fn write_cast(column: &str) -> &'static str { - match column { - "f_price" => "::numeric", - "f_stock" => "::integer", - "f_delete_mark" => "::integer", - "f_creator_time" => "::timestamp", - _ => "", - } -} - -/// 构造读回投影(`f_xxx AS ""`,**每列都带双引号**)。 -fn projection(spec: &EntitySpec) -> Result { - let mut parts: Vec = Vec::with_capacity(spec.columns.len()); - for col in spec.columns { - let name = db::valid_column(col.column).ok_or_else(|| { - pglite::Error::Protocol(format!("非法列名: {}", col.column)) - })?; - let key = json_key_of(col)?; - parts.push(match col.column { - // 🔴 时间列:NULL 时 `to_char(NULL,…) || 'Z'` ⇒ **NULL**(PG 语义),不是 `"Z"`。 - "f_creator_time" => format!( - "to_char({name}, 'YYYY-MM-DD\"T\"HH24:MI:SS') || 'Z' AS \"{key}\"" - ), - // 🔴 numeric 列必须 `::text` ⇒ JSON 是**字符串**(`"9.90"`)。 - _ if col.numeric => format!("{name}::text AS \"{key}\""), - _ => format!("{name} AS \"{key}\""), - }); - } - Ok(parts.join(", ")) -} - -/// 表名过白名单。 -fn table_of(spec: &EntitySpec) -> Result { - db::valid_table(spec.table) - .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {}", spec.table))) -} - -// ---------------------------------------------------------------- 引擎 - -/// 列出未软删的行(契约 §7.6):`f_delete_mark = 0`,按 `f_creator_time DESC`。 -pub async fn list(db: &Db, spec: &EntitySpec) -> Result, pglite::Error> { - let table = table_of(spec)?; - let proj = projection(spec)?; - let sql = format!( - "SELECT {proj} FROM {table} WHERE f_delete_mark = 0 ORDER BY f_creator_time DESC" - ); - db.query_json(&sql).await -} - -/// 新建 / 更新一行(契约 §7.6 的三条路径)⇒ 返回**落库后重新读回**的那一行。 -pub async fn save(db: &Db, spec: &EntitySpec, body: &Value) -> Result { - let table = table_of(spec)?; - let obj: Map = match body { - Value::Object(m) => m.clone(), - _ => Map::new(), - }; - - let id = match body_id(&obj) { - // ---- 路径 1:无 id ⇒ 新建 ---- - None => { - let new_id = insert_new(db, spec, &table, &obj, None).await?; - new_id - } - // ---- 有 id:查库 ⇒ 路径 2(查不到 ⇒ 用该 id 新建)/ 路径 3(查到 ⇒ 覆盖)---- - Some(given_id) => { - if row_exists(db, &table, &given_id).await? { - update_existing(db, spec, &table, &given_id, &obj).await?; - given_id - } else { - insert_new(db, spec, &table, &obj, Some(given_id)).await? - } - } - }; - - // ---- 响应体 = 落库后重新读回的那一行 ---- - fetch_by_id(db, &table, spec, &id) - .await? - .ok_or_else(|| pglite::Error::Protocol(format!("写入后读不回该行: {id}"))) -} - -/// 软删一行(`f_delete_mark = 1`)—— **不检查是否存在** ⇒ 幂等。 -pub async fn remove(db: &Db, spec: &EntitySpec, id: &str) -> Result<(), pglite::Error> { - let table = table_of(spec)?; - // 🔴 一条 UPDATE ⇒ 天然原子(裁决 S16)。 - let sql = format!("UPDATE {table} SET f_delete_mark = 1 WHERE f_id = $1::text"); - db.exec_params(&sql, &[&id]).await -} - -/// 该 id 的行是否存在(**不过滤 `f_delete_mark`** —— 与 react 的 `findOne({where:{id}})` 一致)。 -async fn row_exists(db: &Db, table: &str, id: &str) -> Result { - let sql = format!("SELECT f_id AS \"id\" FROM {table} WHERE f_id = $1::text LIMIT 1"); - let rows = db.query_json_params(&sql, &[&id]).await?; - Ok(!rows.is_empty()) -} - -/// 按 id 读回一行(`None` ⇒ 没有这行)。 -async fn fetch_by_id( - db: &Db, - table: &str, - spec: &EntitySpec, - id: &str, -) -> Result, pglite::Error> { - let proj = projection(spec)?; - let sql = format!("SELECT {proj} FROM {table} WHERE f_id = $1::text LIMIT 1"); - let rows = db.query_json_params(&sql, &[&id]).await?; - Ok(rows.into_iter().next()) -} - -/// 插入一行。 -/// -/// - `forced_id = None` ⇒ **路径 1**:新 uuid + now + `f_delete_mark=0` + spec 的 `default`; -/// - `forced_id = Some(id)` ⇒ **路径 2**:用该 id 新建,**body 没给的列一律不写** -/// (⇒ 走 DDL 的 `DEFAULT` / `NULL`;裁决 S21)。 -/// -/// 🔴 **路径 1 与路径 2 的默认值规则完全不同**,别混用。 -async fn insert_new( - db: &Db, - spec: &EntitySpec, - table: &str, - obj: &Map, - forced_id: Option, -) -> Result { - let mut cols: Vec = Vec::with_capacity(spec.columns.len()); - let mut values: Vec> = Vec::with_capacity(spec.columns.len()); - let mut row_id = String::new(); - - for col in spec.columns { - let name = db::valid_column(col.column).ok_or_else(|| { - pglite::Error::Protocol(format!("非法列名: {}", col.column)) - })?; - - // ---- 主键 ---- - if col.column == "f_id" { - row_id = forced_id.clone().unwrap_or_else(new_uuid); - cols.push(name); - values.push(Some(row_id.clone())); - continue; - } - - // ---- 路径 2:body 没给 ⇒ **不写这一列** ---- - // (⇒ `f_creator_time` ⇒ NULL、`f_status`/`f_price` ⇒ NULL、 - // `f_stock`/`f_delete_mark` ⇒ DDL 的 `DEFAULT 0`) - if forced_id.is_some() { - let Some(v) = obj.get(col.json_key) else { - continue; - }; - cols.push(name); - values.push(value_to_text(Some(v))); - continue; - } - - // ---- 路径 1 ---- - let value: Option = match col.column { - "f_creator_time" => Some(now_str()), - // 🔴 路径 1 的 `f_delete_mark` 恒为 0(react 的 `deleteMark: 0` 写死)。 - "f_delete_mark" => Some("0".to_string()), - // 🔴 `f_creator_user_id` 三张表规则不同(裁决 S22): - // demo ⇒ 硬编码 `'admin'`;其余 ⇒ `body.creatorUserId || 'admin'`。 - // 🔴 走哪条由**业务 spec 的 `creator_fixed`** 决定(平台层不认 app_code)。 - "f_creator_user_id" => match spec.creator_fixed { - Some(fixed) => Some(fixed.to_string()), - None => { - // 🔴 JS `||` 语义(空串 / 数字 0 ⇒ 回落 `'admin'`)。 - match js_truthy_text(obj.get(col.json_key)) { - Some(s) => Some(s), - None => Some(ADMIN_ACCOUNT.to_string()), - } - } - }, - // 其余:body 给了就用;没给 ⇒ spec 的 default;再没有 ⇒ NULL。 - // 🔴 JS `??` 语义(react 的 `item.status ?? '草稿'`):**显式 null 也回落默认值**。 - _ => match obj.get(col.json_key) { - Some(Value::Null) | None => col.default.map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }; - cols.push(name); - values.push(value); - } - - if cols.is_empty() { - return Err(pglite::Error::Protocol("没有可写入的列".to_string())); - } - - let placeholders: Vec = (1..=values.len()) - .map(|i| format!("${i}::text{}", write_cast(&cols[i - 1]))) - .collect(); - let sql = format!( - "INSERT INTO {table} ({}) VALUES ({})", - cols.join(", "), - placeholders.join(", ") - ); - db.exec_params(&sql, ¶ms_of(&values)).await?; - Ok(row_id) -} - -/// 覆盖更新一行(路径 3):**只覆盖 body 里出现的该实体已知列**(`Object.assign` 语义)。 -async fn update_existing( - db: &Db, - spec: &EntitySpec, - table: &str, - id: &str, - obj: &Map, -) -> Result<(), pglite::Error> { - let mut assigns: Vec = Vec::new(); - let mut values: Vec> = Vec::new(); - - for col in spec.columns { - // 🔴 主键不参与更新。 - if col.column == "f_id" { - continue; - } - let Some(name) = db::valid_column(col.column) else { - continue; - }; - // 🔴 body 里没有这个键 ⇒ **不动原值**。 - let Some(v) = obj.get(col.json_key) else { - continue; - }; - values.push(value_to_text(Some(v))); - // 🔴 与 `insert_new` 同一写法:值一律按 text 传 ⇒ `$n::text` **必须**带上, - // 否则 PG 会把参数**推断成**目标列类型(`::timestamp` / `::numeric` / `::integer`) - // ⇒ pglite 拿 `Option` 去绑一个 timestamp 参数 ⇒ 直接报 - // `cannot convert between the Rust type ... and the Postgres type timestamp`。 - assigns.push(format!( - "{name} = ${}::text{}", - values.len(), - write_cast(col.column) - )); - } - - // body 里没有任何已知列 ⇒ 什么都不改(react 的 `Object.assign(existing, {})`)。 - if assigns.is_empty() { - return Ok(()); - } - - values.push(Some(id.to_string())); - let sql = format!( - "UPDATE {table} SET {} WHERE f_id = ${}::text", - assigns.join(", "), - values.len() - ); - db.exec_params(&sql, ¶ms_of(&values)).await -} - -// ---------------------------------------------------------------- 守卫 + handler - -/// 按 spec 的 `module_key` 做守卫: -/// - `None` ⇒ **仅登录**; -/// - `Some(k)` ⇒ 登录 + 菜单权限(`require_module` 内含登录判定,**不要**再叠 `require_login`)。 -async fn guard( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, -) -> Result> { - match spec.module_key { - None => require_login(state, headers).await, - Some(key) => require_module(state, headers, key).await, - } -} - -/// List 的通用实现。 -pub(crate) async fn handle_list( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, -) -> Json { - if let Err(resp) = guard(state, headers, spec).await { - return resp; - } - match list(&state.db, spec).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "业务列表查询"), - } -} - -/// Save 的通用实现。 -pub(crate) async fn handle_save( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - body: &Bytes, -) -> Json { - if let Err(resp) = guard(state, headers, spec).await { - return resp; - } - let obj = match parse_body(body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let value = Value::Object(obj); - match save(&state.db, spec, &value).await { - Ok(row) => ok(row), - Err(e) => db_error(e, "业务保存"), - } -} - -/// Delete 的通用实现(**不检查是否存在** ⇒ 幂等)。 -pub(crate) async fn handle_delete( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - raw: &RawQuery, -) -> Json { - if let Err(resp) = guard(state, headers, spec).await { - return resp; - } - let id = query_param(raw, "id"); - match remove(&state.db, spec, &id).await { - Ok(()) => ok(Value::Null), - Err(e) => db_error(e, "业务删除"), - } -} - -// ---------------------------------------------------------------- spec 取值(编译期常量) -// -// 🔴 **平台层不持有任何业务 spec** —— spec 全在 [`crate::modules`](demo / shop / books)。 -// 引擎只认传入的 `&EntitySpec` ⇒ 加一张新业务表**不用改本文件**。 - -#[cfg(test)] -mod tests { - use super::*; - - /// 投影里**每一列都带双引号别名**,且 numeric 列 `::text`、时间列 `to_char`。 - #[test] - fn projection_uses_quoted_aliases() { - let product = &crate::modules::shop::PRODUCT_SPEC; - let proj = projection(product).expect("投影构造"); - assert!(proj.contains(r#"f_id AS "id""#), "投影: {proj}"); - assert!(proj.contains(r#"f_price::text AS "price""#), "投影: {proj}"); - assert!( - proj.contains(r#"to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime""#), - "投影: {proj}" - ); - // 🔴 不得出现 `SELECT *`。 - assert!(!proj.contains('*'), "投影: {proj}"); - } - - /// 三张表的投影列数 = spec 列数。 - #[test] - fn projection_covers_every_spec_column() { - for spec in crate::modules::all_specs() { - let proj = projection(spec).expect("投影构造"); - let count = proj.split(" AS ").count() - 1; - assert_eq!(count, spec.columns.len(), "{} 的投影列数不对", spec.table); - } - } - - /// `body_id` 的判定与 `sys.rs::body_id` 一致(裁决 S20)。 - #[test] - fn body_id_semantics() { - let mut obj = Map::new(); - assert_eq!(body_id(&obj), None, "键不存在 ⇒ 无 id"); - obj.insert("id".to_string(), Value::Null); - assert_eq!(body_id(&obj), None, "null ⇒ 无 id"); - obj.insert("id".to_string(), Value::String(String::new())); - assert_eq!(body_id(&obj), None, "空串 ⇒ 无 id"); - obj.insert("id".to_string(), Value::String("abc".to_string())); - assert_eq!(body_id(&obj), Some("abc".to_string())); - obj.insert("id".to_string(), Value::Number(123.into())); - assert_eq!(body_id(&obj), Some("123".to_string()), "数字也算有 id"); - } - - /// 写入口的类型转换:`f_price` ⇒ numeric、`f_stock` ⇒ integer、`f_creator_time` ⇒ timestamp。 - #[test] - fn write_casts() { - assert_eq!(write_cast("f_price"), "::numeric"); - assert_eq!(write_cast("f_stock"), "::integer"); - assert_eq!(write_cast("f_delete_mark"), "::integer"); - assert_eq!(write_cast("f_creator_time"), "::timestamp"); - assert_eq!(write_cast("f_title"), ""); - } - - /// body 值 ⇒ 文本:字符串原样、数字 / 布尔转文本、null / 对象 / 数组 ⇒ None。 - #[test] - fn value_to_text_rules() { - assert_eq!( - value_to_text(Some(&Value::String("x".to_string()))), - Some("x".to_string()) - ); - assert_eq!( - value_to_text(Some(&Value::Number(100.into()))), - Some("100".to_string()) - ); - assert_eq!( - value_to_text(Some(&Value::Bool(true))), - Some("true".to_string()) - ); - assert_eq!(value_to_text(Some(&Value::Null)), None); - assert_eq!(value_to_text(Some(&Value::Array(vec![]))), None); - assert_eq!(value_to_text(None), None); - } - - /// spec 的 json_key 与契约映射不一致 ⇒ 报错(而不是静默产出错键名)。 - #[test] - fn json_key_mismatch_is_rejected() { - let bad = ColumnSpec { - column: "f_title", - json_key: "Title", - default: None, - numeric: false, - }; - assert!(json_key_of(&bad).is_err()); - } - - /// 🔴 **numeric 列必须落在 `write_cast` 的 `::numeric` 映射里**。 - /// - /// 少了这层转换 ⇒ PG 报 `column is of type numeric but expression is of type text` - /// ⇒ 只在**运行时**变成「系统异常」信封,编译期 / 启动期无任何提示。 - #[test] - fn every_numeric_spec_column_has_a_numeric_write_cast() { - let mut numeric_cols = 0usize; - for spec in crate::modules::all_specs() { - for col in spec.columns { - if col.numeric { - numeric_cols += 1; - assert_eq!( - write_cast(col.column), - "::numeric", - "{} 的 {} 是 numeric 列,写入必须带 ::numeric", - spec.table, - col.column - ); - } - } - } - assert!(numeric_cols > 0, "必须至少有一个 numeric 列(否则本测试空转)"); - // 其余硬编码的类型转换也一并钉住。 - assert_eq!(write_cast("f_stock"), "::integer"); - assert_eq!(write_cast("f_delete_mark"), "::integer"); - assert_eq!(write_cast("f_creator_time"), "::timestamp"); - } -} diff --git a/src/backend/src/platform/db.rs b/src/backend/src/platform/db.rs deleted file mode 100644 index 2b7f3d3..0000000 --- a/src/backend/src/platform/db.rs +++ /dev/null @@ -1,1091 +0,0 @@ -//! db —— pglite 封装(单 backend 串行化 + schema 初始化 + `row_to_json` 序列化)。 -//! -//! 契约:`docs/contract.md` §5.4 / §5.5。 -//! -//! 官方 7 张 `base_*` 的 DDL 原文(逐字)见 `src/backend/db/schema.sql`。 -//! 该文件**不在 web root**,杜绝「DDL 可从 HTTP 下载」。 -//! -//! 🔴 三条硬约束(来自规格与裁决): -//! 1. pglite-rs 0.2.7 **没有** `exec_params` ⇒ 在 `query(sql, params)` 之上实现(S1)。 -//! 2. 序列化只有一条路:`SELECT row_to_json(q)::text AS _row FROM () AS q` -//! ⇒ 单列 text ⇒ `serde_json::from_str`。**不另起逐列类型映射分支**(S2)。 -//! 3. pglite 自己的 `serial_guard()` 只覆盖**单次**调用;「一次业务操作跨多条 query」 -//! 必须由本层进程级 `tokio::sync::Mutex` 兜住(S3)。 -//! -//! 🔴 **JSON 键的大小写**:PostgreSQL 会把**未加双引号**的别名折叠成小写 -//! (`AS realName` ⇒ 输出列名 `realname`)⇒ `row_to_json` 出来的键会变成 `realname`, -//! 与契约的 `realName` 对不上。⇒ `query_json` 内部做键归一(见 [`normalize_json_keys`]), -//! **两种投影写法都支持**:`AS ` 与直接投影 `f_*` 列。 -//! -//! 🔴 键归一**只认外层 SELECT 的投影列表**(相对括号深度 0)—— CTE / 子查询 / -//! `CAST(x AS TYPE)` 里的 `AS` 一律不登记 ⇒ 不会跨作用域污染别的列的键。 - -use std::collections::{HashMap, HashSet}; -use std::path::Path; -use std::sync::Arc; - -use pglite::{PGlite, ToSql}; -use serde_json::Value; -use tokio::sync::Mutex; - -/// 重新导出 pglite crate。 -/// -/// `Db` 的公开签名里出现 `pglite::Error` / `pglite::ToSql`,下游(集成测试 crate、 -/// 未来的独立 crate)要构造这些类型就必须能引用 pglite —— 而本仓的 `Cargo.toml` -/// **不重复声明**该依赖(依赖版本由 workspace 根统一锁死),所以在这里开一个口子。 -pub use pglite; - -/// 完整 schema DDL 原文(官方 `base_*` CREATE TABLE 逐字 + 业务表 3 张)。 -pub const SCHEMA_SQL: &str = include_str!("../../db/schema.sql"); - -/// `PGLITE_DIR=memory://` 的临时库标记(与 `config::TEMP_DIR_MARKER` 同值)。 -const TEMP_DIR_MARKER: &str = "memory://"; - -// PostgreSQL 内建类型 OID(`scalar_text` 按列类型分派时只需这几个)。 -const OID_TEXT: u32 = 25; -const OID_VARCHAR: u32 = 1043; -const OID_BPCHAR: u32 = 1042; -const OID_NAME: u32 = 19; -const OID_UNKNOWN: u32 = 705; -const OID_BOOL: u32 = 16; -const OID_INT2: u32 = 21; -const OID_INT4: u32 = 23; -const OID_INT8: u32 = 20; - -/// pglite 封装。 -/// -/// 🔴 **一个进程一辈子只能开一个实例**(pglite 内部是进程级全局标志: -/// 第二次 `open()` ⇒ `Error::AlreadyOpen`;关掉再开 ⇒ `Error::ReopenUnsupported`)。 -/// ⇒ 集成测试必须全文件共用一个实例。 -#[derive(Clone)] -pub struct Db { - pg: PGlite, - /// 进程级业务锁(S3)。`Arc` 是因为 `Db` 需要 `Clone`。 - lock: Arc>, -} - -impl Db { - /// 打开(磁盘)数据目录。 - /// - /// `dir` 为 `memory://` ⇒ 等价于 `open_temp()`(pglite 0.2.7 没有真内存模式)。 - pub async fn open(dir: &Path) -> Result { - if dir == Path::new(TEMP_DIR_MARKER) { - return Self::open_temp().await; - } - let pg = PGlite::open(dir).await?; - Ok(Self::new(pg)) - } - - /// 打开临时库(系统临时目录里的一次性数据目录,进程退出即销毁)。 - pub async fn open_temp() -> Result { - let pg = PGlite::open_temp().await?; - Ok(Self::new(pg)) - } - - fn new(pg: PGlite) -> Db { - Db { - pg, - lock: Arc::new(Mutex::new(())), - } - } - - /// schema 初始化(**只在 `base_user` 不存在时**整体执行一次)。 - /// - /// - 探测用 `to_regclass('public.base_user')`(一次 round-trip,S5)。 - /// - 存在 ⇒ 直接返回(**不是**「每次启动都跑 schema.sql」,§5.5)。 - /// - 不存在 ⇒ 按 `;` 切分(**字面量感知**)后逐条 exec。 - pub async fn ensure_schema(&self) -> Result<(), pglite::Error> { - let _guard = self.lock.lock().await; - let existing = self - .scalar_text_inner("SELECT to_regclass('public.base_user')::text") - .await?; - if existing.is_some() { - return Ok(()); - } - for stmt in split_sql_statements(SCHEMA_SQL) { - self.pg.exec(&stmt).await?; - } - Ok(()) - } - - /// 查一批行 ⇒ JSON 数组(每行一个对象)。 - /// - /// 🔴 调用方给的 SQL **必须自带 `AS ` 别名** —— - /// `row_to_json` 用的就是列的**输出名**当 JSON 键。 - pub async fn query_json(&self, sql: &str) -> Result, pglite::Error> { - let _guard = self.lock.lock().await; - self.query_json_inner(sql, &[]).await - } - - /// 同 [`Db::query_json`],但带参数(占位符 `$1, $2, …` 由**内层** SQL 消费)。 - pub async fn query_json_params( - &self, - sql: &str, - params: &[&(dyn ToSql + Sync)], - ) -> Result, pglite::Error> { - let _guard = self.lock.lock().await; - self.query_json_inner(sql, params).await - } - - /// 执行(无返回值)语句。 - /// - /// 🔴 走 **simple protocol** ⇒ **可以一次执行多条语句**,且整批是一个**隐式事务** - /// (其中一条失败 ⇒ 整批回滚)。 - pub async fn exec(&self, sql: &str) -> Result<(), pglite::Error> { - let _guard = self.lock.lock().await; - self.pg.exec(sql).await - } - - /// 执行带参数语句。 - /// - /// 🔴 pglite-rs 0.2.7 **没有** `exec_params`(S1)⇒ 在 `query(sql, params)` 之上实现, - /// 拿到结果集后丢弃即可。 - /// - /// ⚠️ `query` 走 **extended protocol** ⇒ **只能单语句**:多语句会被 PG 拒 - /// (`cannot insert multiple commands into a prepared statement`)。 - /// 要多语句 ⇒ 用 [`Db::exec`](simple protocol,整批一个隐式事务)。 - pub async fn exec_params( - &self, - sql: &str, - params: &[&(dyn ToSql + Sync)], - ) -> Result<(), pglite::Error> { - let _guard = self.lock.lock().await; - self.pg.query(sql, params).await.map(|_| ()) - } - - /// 取第一行的第一列 ⇒ 文本;无行或 NULL ⇒ `None`。 - /// - /// 🔴 **调用方自己保证列是文本或整数/布尔**,其它类型(numeric / timestamp / json …) - /// 会**报错**(不猜格式)—— 要字符串就在 SQL 里显式写 `::text`。 - /// - /// 支持的列类型:text / varchar / bpchar / name / unknown(直出)、 - /// int2 / int4 / int8 / bool(转十进制文本,`bool` ⇒ `"true"` / `"false"`)。 - pub async fn scalar_text(&self, sql: &str) -> Result, pglite::Error> { - let _guard = self.lock.lock().await; - self.scalar_text_inner(sql).await - } - - /// 优雅关闭底层 pglite 后端(SIGTERM / SIGINT 停机路径用)。 - /// - /// 🔴 以前后端**忽略 SIGTERM** ⇒ 每次停机都是 `SIGKILL` 掉嵌入式 PostgreSQL - /// ⇒ 下次启动要 crash recovery,数据目录里还留 `postmaster.pid`。 - /// 现在停机路径会先让 HTTP 服务收完在途请求,再调这里正常关库。 - pub async fn shutdown(&self) -> Result<(), pglite::Error> { - self.pg.shutdown().await - } - - // ---- 以下为**持锁调用**的内部实现(调用方已持有 `self.lock`)---- - - async fn query_json_inner( - &self, - sql: &str, - params: &[&(dyn ToSql + Sync)], - ) -> Result, pglite::Error> { - let inner = trim_sql(sql); - // 预先扫出**外层投影列表**的 `AS <别名>` ⇒ 查询后能把 PG 折叠掉的大写还原回去。 - let alias_info = collect_alias_info(inner); - let wrapped = format!("SELECT row_to_json(q)::text AS _row FROM ({inner}) AS q"); - let rows = self.pg.query(&wrapped, params).await?; - let mut out = Vec::with_capacity(rows.len()); - for row in rows { - // `_row` 是 text 列;理论上 row_to_json 不会是 NULL,保险起见按 Option 处理。 - let Some(text) = row.get::>(0)? else { - continue; - }; - let value = serde_json::from_str::(&text).map_err(|e| { - pglite::Error::Protocol(format!("row_to_json 结果反序列化失败: {e}")) - })?; - out.push(normalize_json_keys(value, &alias_info)); - } - Ok(out) - } - - /// 取第一行的第一列 ⇒ 文本。 - /// - /// 🔴 **按列类型 OID 分派**(不猜):文本类直接取;整型/布尔转十进制文本; - /// 其它类型(numeric / timestamp / json …)⇒ **报错**,让调用方自己写 `::text`。 - /// - /// ⚠️ 不能直接 `row.get::>(0)`:postgres-types 的 - /// `String::from_sql` **不校验列类型**,对非 text 列就是拿二进制字节做 `from_utf8` - /// (`count(*)` ⇒ 8 个 NUL,静默判错)。 - async fn scalar_text_inner(&self, sql: &str) -> Result, pglite::Error> { - let rows = self.pg.query(sql, &[]).await?; - let Some(row) = rows.first() else { - return Ok(None); - }; - let Some(col) = row.columns().first() else { - return Ok(None); - }; - let oid = col.type_().oid(); - match oid { - OID_TEXT | OID_VARCHAR | OID_BPCHAR | OID_NAME | OID_UNKNOWN => { - Ok(row.get::>(0)?) - } - OID_INT8 => Ok(row.get::>(0)?.map(|v| v.to_string())), - OID_INT4 => Ok(row.get::>(0)?.map(|v| v.to_string())), - OID_INT2 => Ok(row.get::>(0)?.map(|v| v.to_string())), - OID_BOOL => Ok(row.get::>(0)?.map(|v| v.to_string())), - other => Err(pglite::Error::Protocol(format!( - "scalar_text 不接受列类型 {}(OID {other})——请在 SQL 里显式 ::text 转换", - col.type_().name() - ))), - } - } -} - -/// 去掉首尾空白与**结尾**的分号(调用方的 SQL 常带 `;`;包成子查询时不能留)。 -fn trim_sql(sql: &str) -> &str { - sql.trim().trim_end_matches(';').trim_end() -} - -/// 🔴 JSON 键归一(**本仓最容易被踩的坑**,务必读)。 -/// -/// PostgreSQL 会把**未加双引号**的别名折叠成小写: -/// `SELECT 1 AS realName` 的输出列名是 `realname` ⇒ `row_to_json` 出来的 JSON 键 -/// 是 `"realname"`,而契约要的是 `"realName"` ⇒ 前端读不到字段。 -/// (实测:PG 17.5 `SELECT row_to_json(q)::text FROM (SELECT 1 AS realName) q` -/// ⇒ `{"realname":1}`;写成 `AS "realName"` 才是 `{"realName":1}`。) -/// -/// ⇒ 本仓在 `query_json` 里做**两件事**(两种投影写法都支持): -/// 1. **别名还原**:把 PG 折叠掉的大写按作者原样还原(`AS realName` ⇒ 键 `realName`)。 -/// 2. **列名映射**:键以 `f_` 开头 ⇒ 走 `column_to_json_key` -/// (`f_real_name` ⇒ `realName`)—— 与 `tdc-rs` 的做法一致(那边是 -/// `row_to_json(row)` 在 Rust 侧把 `f_*` 列名转 camelCase)。 -/// -/// 🔴 **作用域**:别名只在**外层 SELECT 的投影列表**里找(相对括号深度 0)—— -/// CTE / 子查询 / `CAST(x AS TYPE)` 里的 `AS` 一律不登记。 -/// 否则 `WITH c AS (SELECT 1 AS Title) SELECT f_title AS "title" FROM t_item` -/// 会把 `title` 键静默改成 `Title` ⇒ **前端读不到字段且不报错**。 -/// -/// 归一顺序(**不可换**):双引号别名(契约写法,权威)> 折叠还原 > `f_` 列名映射。 -fn normalize_json_keys(value: Value, info: &AliasInfo) -> Value { - let Some(obj) = value.as_object() else { - return value; - }; - let mut out = serde_json::Map::new(); - for (key, val) in obj { - let new_key = if info.quoted.contains(key) { - // ① 加了双引号的别名 = 权威名,一个字都不动 - key.clone() - } else if let Some(orig) = info.folded.get(key) { - // ② 未加引号的别名被 PG 折叠 ⇒ 按作者写法还原 - orig.clone() - } else if key.starts_with("f_") { - // ③ 直接投影 f_ 列 ⇒ camelCase - column_to_json_key(key) - } else { - key.clone() - }; - out.insert(new_key, val.clone()); - } - Value::Object(out) -} - -/// 投影别名信息。 -#[derive(Debug, Default, Clone)] -pub struct AliasInfo { - /// 未加双引号、含大写字母的别名:`PG 折叠后的小写名 -> 作者原样写法`。 - folded: HashMap, - /// 加了双引号的别名(PG **原样保留大小写**):作者原样写法。 - quoted: HashSet, -} - -/// 扫出**外层 SELECT 投影列表**里的 `AS <别名>`。 -/// -/// 扫描规则: -/// 1. 记括号深度(`(` 加一、`)` 减一;跳过器内部的括号不计数)。 -/// 2. 找**第一个括号深度为 0 的 `SELECT`** ⇒ 它就是外层 SELECT;找不到 ⇒ 空结果。 -/// 3. 扫描范围 = 该 SELECT 之后 ⇒ **第一个括号深度为 0 的 `FROM`**(没有则到末尾)。 -/// 4. 范围内**只有相对深度为 0 的 `AS`** 才是别名: -/// - 下一个非空白字符是 `"` ⇒ 双引号别名 ⇒ 进 `quoted`(原样,不做小写折叠); -/// - 否则是标识符且**含 ASCII 大写字母** ⇒ 进 `folded`(小写名 -> 原样写法); -/// - 深度 > 0 的 `AS`(如 `CAST(1 AS NUMERIC)`)一律不登记。 -/// 5. **歧义**:同一个 `folded` 的小写键对应两个不同的原样写法 ⇒ **删除该键** -/// (宁可不还原,也不要乱改)。 -fn collect_alias_info(sql: &str) -> AliasInfo { - let mut info = AliasInfo::default(); - let b = sql.as_bytes(); - - // ---- 阶段一:定位外层 SELECT(第一个深度 0 的 SELECT)---- - let mut i = 0usize; - let mut depth: i32 = 0; - let mut select_end: Option = None; - while i < b.len() { - match b[i] { - b'\'' => { - i = skip_single_quoted(b, i); - continue; - } - b'"' => { - i = skip_double_quoted(b, i); - continue; - } - b'-' if b.get(i + 1) == Some(&b'-') => { - i = skip_line_comment(b, i); - continue; - } - b'/' if b.get(i + 1) == Some(&b'*') => { - i = skip_block_comment(b, i); - continue; - } - b'$' => { - if let Some(tag_end) = dollar_tag_end(b, i) { - i = skip_dollar_quoted(sql, b, i, tag_end); - continue; - } - } - b'(' => { - depth += 1; - i += 1; - continue; - } - b')' => { - depth -= 1; - i += 1; - continue; - } - _ => {} - } - let c = b[i]; - if c.is_ascii_alphabetic() || c == b'_' { - let word_end = read_word_end(b, i); - if depth == 0 && sql[i..word_end].eq_ignore_ascii_case("SELECT") { - select_end = Some(word_end); - break; - } - i = word_end; - continue; - } - i += 1; - } - let Some(select_end) = select_end else { - return info; - }; - - // ---- 阶段二:扫外层投影列表(到第一个深度 0 的 FROM 为止)---- - // `ambiguous` 只在本次扫描内有效:同名不同写法 ⇒ 放弃还原(键干脆不登记)。 - let mut ambiguous: HashSet = HashSet::new(); - let mut i = select_end; - let mut depth: i32 = 0; - while i < b.len() { - match b[i] { - b'\'' => { - i = skip_single_quoted(b, i); - continue; - } - b'"' => { - i = skip_double_quoted(b, i); - continue; - } - b'-' if b.get(i + 1) == Some(&b'-') => { - i = skip_line_comment(b, i); - continue; - } - b'/' if b.get(i + 1) == Some(&b'*') => { - i = skip_block_comment(b, i); - continue; - } - b'$' => { - if let Some(tag_end) = dollar_tag_end(b, i) { - i = skip_dollar_quoted(sql, b, i, tag_end); - continue; - } - } - b'(' => { - depth += 1; - i += 1; - continue; - } - b')' => { - depth -= 1; - i += 1; - continue; - } - _ => {} - } - let c = b[i]; - if c.is_ascii_alphabetic() || c == b'_' { - let word_end = read_word_end(b, i); - let word = &sql[i..word_end]; - if depth == 0 && word.eq_ignore_ascii_case("FROM") { - break; // 外层投影列表结束 - } - if depth == 0 && word.eq_ignore_ascii_case("AS") { - let mut j = word_end; - while j < b.len() && b[j].is_ascii_whitespace() { - j += 1; - } - if j < b.len() && b[j] == b'"' { - // 双引号别名:PG 原样保留大小写 ⇒ 进 quoted - let (content, end) = read_quoted_ident(sql, b, j); - info.quoted.insert(content); - i = end; - continue; - } - if j < b.len() && (b[j].is_ascii_alphabetic() || b[j] == b'_') { - let ident_end = read_word_end(b, j); - let ident = &sql[j..ident_end]; - if ident.chars().any(|ch| ch.is_ascii_uppercase()) { - let key = ident.to_ascii_lowercase(); - if ambiguous.contains(&key) { - // 已经判定为歧义 ⇒ 不再登记 - } else if let Some(prev) = info.folded.get(&key) { - if prev != ident { - // 同名不同写法 ⇒ 放弃还原 - info.folded.remove(&key); - ambiguous.insert(key); - } - } else { - info.folded.insert(key, ident.to_string()); - } - } - i = ident_end; - continue; - } - // 其它(如 `AS (`)⇒ 不是别名,继续往后扫 - } - i = word_end; - continue; - } - i += 1; - } - info -} - -/// 读一段双引号标识符的内容(`i` 指向开头的 `"`),返回 `(内容, 结束位置)`。 -/// -/// `""` 是转义的单引号 ⇒ 内容里还原成一个 `"`。 -fn read_quoted_ident(sql: &str, b: &[u8], i: usize) -> (String, usize) { - let mut out = String::new(); - let mut j = i + 1; - while j < b.len() { - if b[j] == b'"' { - if b.get(j + 1) == Some(&b'"') { - out.push('"'); - j += 2; - continue; - } - j += 1; - break; - } - let c = sql[j..].chars().next().unwrap_or('\0'); - out.push(c); - j += c.len_utf8(); - } - (out, j) -} - -/// 跳过一段单引号串(`i` 指向开头的 `'`),返回结束位置。 -fn skip_single_quoted(b: &[u8], i: usize) -> usize { - let is_escape = i >= 2 - && (b[i - 1] == b'E' || b[i - 1] == b'e') - && !(b[i - 2].is_ascii_alphanumeric() || b[i - 2] == b'_'); - let mut j = i + 1; - while j < b.len() { - if is_escape && b[j] == b'\\' { - j += 2; - continue; - } - if b[j] == b'\'' { - if b.get(j + 1) == Some(&b'\'') { - j += 2; - continue; - } - return j + 1; - } - j += 1; - } - b.len() -} - -/// 跳过一段双引号标识符(`i` 指向开头的 `"`),返回结束位置。 -fn skip_double_quoted(b: &[u8], i: usize) -> usize { - let mut j = i + 1; - while j < b.len() { - if b[j] == b'"' { - if b.get(j + 1) == Some(&b'"') { - j += 2; - continue; - } - return j + 1; - } - j += 1; - } - b.len() -} - -/// 跳过行注释(`i` 指向 `-`),返回结束位置。 -fn skip_line_comment(b: &[u8], i: usize) -> usize { - let mut j = i + 2; - while j < b.len() && b[j] != b'\n' { - j += 1; - } - j -} - -/// 跳过块注释(`i` 指向 `/`,可嵌套),返回结束位置。 -fn skip_block_comment(b: &[u8], i: usize) -> usize { - let mut depth = 1usize; - let mut j = i + 2; - while j < b.len() { - if b[j] == b'/' && b.get(j + 1) == Some(&b'*') { - depth += 1; - j += 2; - continue; - } - if b[j] == b'*' && b.get(j + 1) == Some(&b'/') { - depth -= 1; - j += 2; - if depth == 0 { - break; - } - continue; - } - j += 1; - } - j -} - -/// 跳过 dollar-quote 段(`i` 指向开头的 `$`,`tag_end` 是 tag 末尾 `$` 的下标)。 -fn skip_dollar_quoted(sql: &str, b: &[u8], i: usize, tag_end: usize) -> usize { - let tag = &sql[i..=tag_end]; - let rest = &sql[tag_end + 1..]; - match rest.find(tag) { - Some(pos) => tag_end + 1 + pos + tag.len(), - None => b.len(), - } -} - -/// 读一个单词(`[A-Za-z0-9_$]*`)的结束位置。 -fn read_word_end(b: &[u8], i: usize) -> usize { - let mut j = i; - while j < b.len() && (b[j].is_ascii_alphanumeric() || b[j] == b'_' || b[j] == b'$') { - j += 1; - } - j -} - -/// 列名 → JSON 键:去 `f_` 前缀 + `_` 拆词 camelCase。 -/// -/// `f_real_name` ⇒ `realName`;`f_id` ⇒ `id`;`f_is_administrator` ⇒ `isAdministrator`。 -pub fn column_to_json_key(col: &str) -> String { - let core = col.strip_prefix("f_").unwrap_or(col); - let mut out = String::with_capacity(core.len()); - for (i, part) in core.split('_').enumerate() { - if i == 0 { - out.push_str(part); - } else if let Some(first) = part.chars().next() { - out.extend(first.to_uppercase()); - out.push_str(&part[first.len_utf8()..]); - } - } - out -} - -/// JSON 键 → 列名([`column_to_json_key`] 的逆)。 -/// -/// `realName` ⇒ `f_real_name`;`id` ⇒ `f_id`;`isAdministrator` ⇒ `f_is_administrator`。 -pub fn json_key_to_column(key: &str) -> String { - let chars: Vec = key.chars().collect(); - let mut snake = String::with_capacity(key.len() + 2); - for (i, &c) in chars.iter().enumerate() { - if c.is_uppercase() { - let prev_lower = i > 0 && (chars[i - 1].is_lowercase() || chars[i - 1].is_ascii_digit()); - let prev_upper = i > 0 && chars[i - 1].is_uppercase(); - let next_lower = i + 1 < chars.len() && chars[i + 1].is_lowercase(); - if i > 0 && (prev_lower || (prev_upper && next_lower)) { - snake.push('_'); - } - snake.extend(c.to_lowercase()); - } else { - snake.push(c); - } - } - format!("f_{snake}") -} - -/// 表名白名单:只收 `[A-Za-z][A-Za-z0-9_]*`。 -/// -/// 🔴 任何拼进 SQL 的标识符都必须过这里(规格 §1.10)。 -pub fn valid_table(name: &str) -> Option { - valid_identifier(name) -} - -/// 列名白名单:只收 `[A-Za-z][A-Za-z0-9_]*`。 -pub fn valid_column(name: &str) -> Option { - valid_identifier(name) -} - -fn valid_identifier(name: &str) -> Option { - let mut chars = name.chars(); - match chars.next() { - Some(c) if c.is_ascii_alphabetic() => {} - _ => return None, - } - if !chars.all(|c| c.is_ascii_alphanumeric() || c == '_') { - return None; - } - Some(name.to_string()) -} - -/// [`SCHEMA_SQL`] 里 `CREATE TABLE` 的**全部表名**(按出现顺序)。 -/// -/// 🔴 **为什么要有它**:契约 §5.1 的表清单 = 7 张 `base_*` + N 张业务表。 -/// 业务表名是**业务知识** ⇒ 不许在平台层/入口写死(红线 12) -/// ⇒ 「这张表存在吗」这个判据必须**从 DDL 里读**(`db/schema.sql` 是数据模型真源)。 -/// -/// 🔴 **只认行首的 `CREATE TABLE`**(DDL 里 `CREATE TABLE` 都在行首) -/// ⇒ 不会把 `CREATE TABLE` 出现在注释/字符串里的情况算进来。 -pub fn ddl_tables() -> Vec { - let mut out = Vec::new(); - for line in SCHEMA_SQL.lines() { - let t = line.trim_start(); - let Some(rest) = t.strip_prefix("CREATE TABLE ") else { - continue; - }; - let name: String = rest - .chars() - .take_while(|c| c.is_ascii_alphanumeric() || *c == '_') - .collect(); - if !name.is_empty() { - out.push(name); - } - } - out -} - -/// 字面量感知的 SQL 切分。 -/// -/// 单引号串(含 `E'...'` 的反斜杠转义)、双引号标识符、`$$...$$` / `$tag$...$tag$`、 -/// 行注释 `--`、块注释 `/* */`(PG 语义**可嵌套**)里的 `;` **不切**。 -/// 注释内容会被丢弃(不进结果),只保留换行以维持行号;注释处会补**一个空格** -/// ⇒ 注释不会把两边的 token 粘在一起(`SELECT 1/*x*/FROM t` ⇒ `SELECT 1 FROM t`)。 -/// -/// `$1` / `$2` 这类占位符**不是** dollar-quote,按普通字符处理。 -pub fn split_sql_statements(sql: &str) -> Vec { - let b = sql.as_bytes(); - let mut out: Vec = Vec::new(); - let mut cur = String::new(); - let mut i = 0usize; - - while i < b.len() { - match b[i] { - b'-' if b.get(i + 1) == Some(&b'-') => { - // 行注释:丢弃到行尾(换行留给外层逻辑处理) - // ⚠️ 推一个空格 ⇒ 注释不会把两边的 token 粘在一起(`1--x\nFROM` ⇒ `1 FROM`) - cur.push(' '); - i += 2; - while i < b.len() && b[i] != b'\n' { - i += 1; - } - } - b'/' if b.get(i + 1) == Some(&b'*') => { - // 块注释:可嵌套(PG 语义)。`depth` 起始 1 = 已经吃掉了开头的 `/*` - // ⚠️ 同样推一个空格,避免 `SELECT 1/*x*/FROM t` 被切成 `SELECT 1FROM t` - cur.push(' '); - let mut depth = 1usize; - i += 2; - loop { - if i >= b.len() { - break; - } - if b[i] == b'/' && b.get(i + 1) == Some(&b'*') { - depth += 1; - i += 2; - continue; - } - if b[i] == b'*' && b.get(i + 1) == Some(&b'/') { - depth -= 1; - i += 2; - if depth == 0 { - break; - } - continue; - } - if b[i] == b'\n' { - cur.push('\n'); - } - i += 1; - } - } - b'\'' => { - // 单引号串:`E'...'` 走反斜杠转义,普通串只认 `''` - let is_escape = is_escape_prefix(&cur); - cur.push('\''); - i += 1; - while i < b.len() { - let ch = b[i]; - if is_escape && ch == b'\\' { - cur.push('\\'); - i += 1; - if i < b.len() { - let c = sql[i..].chars().next().unwrap_or('\0'); - cur.push(c); - i += c.len_utf8(); - } - continue; - } - if ch == b'\'' { - if b.get(i + 1) == Some(&b'\'') { - cur.push_str("''"); - i += 2; - continue; - } - cur.push('\''); - i += 1; - break; - } - let c = sql[i..].chars().next().unwrap_or('\0'); - cur.push(c); - i += c.len_utf8(); - } - } - b'"' => { - // 双引号标识符:`""` 是转义 - cur.push('"'); - i += 1; - while i < b.len() { - if b[i] == b'"' { - if b.get(i + 1) == Some(&b'"') { - cur.push_str("\"\""); - i += 2; - continue; - } - cur.push('"'); - i += 1; - break; - } - let c = sql[i..].chars().next().unwrap_or('\0'); - cur.push(c); - i += c.len_utf8(); - } - } - b'$' => { - if let Some(tag_end) = dollar_tag_end(b, i) { - let tag = &sql[i..=tag_end]; - cur.push_str(tag); - i = tag_end + 1; - let rest = &sql[i..]; - match rest.find(tag) { - Some(pos) => { - cur.push_str(&rest[..pos]); - i += pos + tag.len(); - } - None => { - // 未闭合:整段当普通文本 - cur.push_str(rest); - i = b.len(); - } - } - continue; - } - let c = sql[i..].chars().next().unwrap_or('\0'); - cur.push(c); - i += c.len_utf8(); - } - b';' => { - let stmt = cur.trim(); - if !stmt.is_empty() { - out.push(stmt.to_string()); - } - cur.clear(); - i += 1; - } - _ => { - let c = sql[i..].chars().next().unwrap_or('\0'); - cur.push(c); - i += c.len_utf8(); - } - } - } - - let stmt = cur.trim(); - if !stmt.is_empty() { - out.push(stmt.to_string()); - } - out -} - -/// 判断紧邻引号的前一个 token 是不是 `E`/`e`(⇒ `E'...'` 反斜杠转义串)。 -fn is_escape_prefix(cur: &str) -> bool { - let b = cur.as_bytes(); - if b.is_empty() { - return false; - } - let last = b[b.len() - 1]; - if last != b'E' && last != b'e' { - return false; - } - if b.len() == 1 { - return true; - } - let prev = b[b.len() - 2]; - !(prev.is_ascii_alphanumeric() || prev == b'_') -} - -/// dollar-quote 的 tag 结束位置(`$` 之后的那个 `$` 的下标);不是 dollar-quote ⇒ `None`。 -/// -/// `$$` ⇒ tag 就是 `$$`;`$tag$` ⇒ tag 是 `$tag$`;`$1`(占位符)⇒ `None`。 -fn dollar_tag_end(b: &[u8], i: usize) -> Option { - let mut j = i + 1; - if j >= b.len() { - return None; - } - let first = b[j]; - if first.is_ascii_digit() { - return None; // $1 / $2 占位符 - } - if !(first.is_ascii_alphabetic() || first == b'_') { - return if first == b'$' { Some(j) } else { None }; - } - while j < b.len() && (b[j].is_ascii_alphanumeric() || b[j] == b'_') { - j += 1; - } - if j < b.len() && b[j] == b'$' { - Some(j) - } else { - None - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn split_keeps_semicolon_inside_literals() { - assert_eq!(split_sql_statements("SELECT 'a;b'").len(), 1); - assert_eq!(split_sql_statements("SELECT $$a;b$$").len(), 1); - assert_eq!(split_sql_statements("SELECT 1 -- a;b").len(), 1); - assert_eq!(split_sql_statements("SELECT /* a;b */ 1").len(), 1); - assert_eq!(split_sql_statements("SELECT 1; SELECT 2").len(), 2); - } - - #[test] - fn split_more_literal_shapes() { - // 双引号标识符里的 `;` 不切 - assert_eq!(split_sql_statements(r#"SELECT "a;b" FROM t"#).len(), 1); - // E'' 串里的 `;` 不切 - assert_eq!(split_sql_statements(r"SELECT E'a;b'").len(), 1); - // $tag$ dollar-quote - assert_eq!(split_sql_statements("SELECT $tag$a;b$tag$").len(), 1); - // 嵌套块注释 - assert_eq!(split_sql_statements("SELECT /* a /* b; */ c; */ 1").len(), 1); - // 占位符不是 dollar-quote - assert_eq!(split_sql_statements("SELECT * FROM t WHERE a = $1; SELECT 2").len(), 2); - // 空串 / 只有空白 ⇒ 0 条 - assert!(split_sql_statements("").is_empty()); - assert!(split_sql_statements(" \n ").is_empty()); - // 只有注释 ⇒ 0 条 - assert!(split_sql_statements("-- 注释\n/* 注释 */").is_empty()); - } - - #[test] - fn split_content_is_trimmed() { - let parts = split_sql_statements(" SELECT 1 ; SELECT 2 "); - assert_eq!(parts.len(), 2); - assert_eq!(parts[0], "SELECT 1"); - assert_eq!(parts[1], "SELECT 2"); - } - - #[test] - fn json_key_mapping() { - assert_eq!(column_to_json_key("f_real_name"), "realName"); - assert_eq!(column_to_json_key("f_id"), "id"); - assert_eq!(column_to_json_key("f_is_administrator"), "isAdministrator"); - assert_eq!(json_key_to_column("realName"), "f_real_name"); - assert_eq!(json_key_to_column("id"), "f_id"); - assert_eq!(json_key_to_column("isAdministrator"), "f_is_administrator"); - } - - #[test] - fn json_key_mapping_is_bijective_over_contract_columns() { - // docs/contract.md §4 的全部列 ⇒ 正反互逆 - let cols = [ - "f_id", - "f_tenant_id", - "f_account", - "f_real_name", - "f_password", - "f_secretkey", - "f_is_administrator", - "f_role_id", - "f_organize_id", - "f_creator_user_id", - "f_creator_time", - "f_enabled_mark", - "f_delete_mark", - "f_full_name", - "f_en_code", - "f_url_address", - "f_parent_id", - "f_sort_code", - "f_type", - "f_category", - "f_icon", - "f_object_type", - "f_object_id", - "f_item_type", - "f_item_id", - "f_user_id", - "f_org_id", - "f_title", - "f_status", - "f_price", - "f_stock", - "f_author", - "f_isbn", - ]; - for col in cols { - let key = column_to_json_key(col); - assert_eq!(json_key_to_column(&key), col, "往返失败: {col} -> {key}"); - } - } - - #[test] - fn alias_map_restores_author_case() { - // 契约 §5.3 的写法:`AS ` - let info = collect_alias_info( - "SELECT f_id AS id, f_real_name AS realName, f_creator_time AS creatorTime FROM base_user", - ); - assert_eq!(info.folded.get("realname").map(String::as_str), Some("realName")); - assert_eq!( - info.folded.get("creatortime").map(String::as_str), - Some("creatorTime") - ); - // 小写别名不进映射(PG 折叠后不变) - assert!(!info.folded.contains_key("id")); - - // 字面量 / 注释里的 AS 不能被误识别 - let info2 = collect_alias_info("SELECT 'AS realName' AS fooName, 1 -- AS barName\n"); - assert_eq!(info2.folded.get("fooname").map(String::as_str), Some("fooName")); - assert!(!info2.folded.contains_key("realname")); - assert!(!info2.folded.contains_key("barname")); - - // 双引号别名**不再进 folded**(进 quoted) - let info3 = collect_alias_info(r#"SELECT f_id AS "realName""#); - assert!(info3.folded.is_empty()); - assert!(info3.quoted.contains("realName")); - } - - #[test] - fn normalize_json_keys_handles_both_styles() { - let info = collect_alias_info("SELECT f_real_name AS realName, f_id AS id"); - - // 风格 A(契约 §5.3):别名是 camelCase —— PG 折叠成小写后被还原 - let v = serde_json::json!({"realname": "张三", "id": "x"}); - let out = normalize_json_keys(v, &info); - assert_eq!(out["realName"], "张三"); - assert_eq!(out["id"], "x"); - - // 风格 B(tdc-rs):直接投影 f_ 列 —— 走 column_to_json_key - let v2 = serde_json::json!({"f_real_name": "张三", "f_id": "x"}); - let out2 = normalize_json_keys(v2, &info); - assert_eq!(out2["realName"], "张三"); - assert_eq!(out2["id"], "x"); - - // 已经是正确 camelCase 的键不受影响 - let v3 = serde_json::json!({"realName": "张三"}); - let out3 = normalize_json_keys(v3, &info); - assert_eq!(out3["realName"], "张三"); - } - - #[test] - fn alias_scope_ignores_nested_and_type_names() { - // 类型名不是别名(`CAST(1 AS NUMERIC)` 的 AS 在深度 1) - let info = collect_alias_info(r#"SELECT CAST(1 AS NUMERIC) AS "numeric""#); - assert!(info.folded.is_empty()); - assert!(info.quoted.contains("numeric")); - - // CTE 里的别名不污染外层 - let info2 = - collect_alias_info(r#"WITH c AS (SELECT 1 AS Title) SELECT f_title AS "title" FROM t_item"#); - assert!(!info2.folded.contains_key("title")); - assert!(info2.quoted.contains("title")); - - // 契约写法:只有双引号别名 - let info3 = collect_alias_info(r#"SELECT f_title AS "title" FROM t_item"#); - assert!(info3.folded.is_empty()); - assert!(info3.quoted.contains("title")); - } - - #[test] - fn normalize_never_renames_a_quoted_alias() { - // CTE 那条:外层是双引号别名 `title` ⇒ 键必须保持 `title` - let info = - collect_alias_info(r#"WITH c AS (SELECT 1 AS Title) SELECT f_title AS "title" FROM t_item"#); - let out = normalize_json_keys(serde_json::json!({"title": "T"}), &info); - assert_eq!(out["title"], "T"); - assert!(out.get("Title").is_none(), "不得凭空多出 Title 键"); - - // CAST 那条:类型名不得被当成别名 - let info2 = collect_alias_info(r#"SELECT CAST(1 AS NUMERIC) AS "numeric""#); - let out2 = normalize_json_keys(serde_json::json!({"numeric": 1}), &info2); - assert_eq!(out2["numeric"], 1); - } - - #[test] - fn ambiguous_folded_alias_is_not_restored() { - // 同名不同写法 ⇒ 放弃还原(宁可不还原,也不要乱改) - let info = collect_alias_info("SELECT a AS Foo, b AS FOO FROM t"); - assert!(!info.folded.contains_key("foo")); - } - - #[test] - fn split_keeps_token_boundary_after_comment() { - let parts = split_sql_statements("SELECT 1/*x*/FROM t"); - assert_eq!(parts.len(), 1); - assert!( - parts[0].contains("1 FROM"), - "注释处应补空格,实际: {:?}", - parts[0] - ); - } - - #[test] - fn identifier_whitelist() { - assert!(valid_table("base_user").is_some()); - assert!(valid_table("base_user; DROP TABLE x").is_none()); - assert!(valid_table("").is_none()); - assert!(valid_table("1abc").is_none()); - assert!(valid_table("用户").is_none()); - assert!(valid_column("f_real_name").is_some()); - assert!(valid_column("1abc").is_none()); - assert!(valid_column("a b").is_none()); - } - - #[test] - fn schema_sql_has_ten_tables() { - // schema.sql 必须包含 10 张表的 CREATE TABLE(7 张 base_* + 3 张业务表) - let count = SCHEMA_SQL.matches("CREATE TABLE ").count(); - assert_eq!(count, 10, "schema.sql 的 CREATE TABLE 数量应为 10"); - } - - /// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 10 却解析出别的)。 - #[test] - fn ddl_tables_parses_every_create_table() { - let tables = ddl_tables(); - assert_eq!(tables.len(), 10, "ddl_tables 应解析出 10 张表"); - assert!(tables.iter().all(|t| !t.is_empty())); - assert_eq!( - tables.iter().collect::>().len(), - 10, - "表名不许重复" - ); - // 7 张 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 - for base in [ - "base_user", - "base_role", - "base_organize", - "base_module", - "base_authorize", - "base_role_relation", - "base_user_relation", - ] { - assert!( - tables.iter().any(|t| t == base), - "ddl_tables 少了 {base}" - ); - } - } -} diff --git a/src/backend/src/platform/entity.rs b/src/backend/src/platform/entity.rs deleted file mode 100644 index a3dd607..0000000 --- a/src/backend/src/platform/entity.rs +++ /dev/null @@ -1,48 +0,0 @@ -//! entity —— **业务实体 spec 的类型定义**(平台层)。 -//! -//! 🔴 **本文件只放「类型」,不放任何业务 spec**——三个业务 spec(demo / shop / books) -//! 在 [`crate::modules`] 下各自成文件(`modules/demo.rs` · `modules/shop.rs` · `modules/books.rs`)。 -//! 加业务模块 ⇒ **只碰 `modules/`,不碰 `platform/`**。 -//! -//! 契约:`docs/contract.md` §5.3(精确列清单 = 投影真源)+ §6.4(端点)+ §9(接口)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/{demo,shop,books}/` -//! 里的 `*.entity.ts`(**列名 / 列序逐字对齐** —— 两版后端要能开同一个库)。 - -/// 一个业务实体的 spec。 -pub struct EntitySpec { - /// 应用码(`"demo"` / `"shop"` / `"books"`)。 - pub app_code: &'static str, - /// 实体名(`"DemoItem"` / `"Product"` / `"Book"`)。 - pub entity: &'static str, - /// 物理表名(`"demo_item"` / `"shop_product"` / `"book_shop_book"`)。 - pub table: &'static str, - /// 菜单守卫 key:`None` ⇒ **仅登录**;`Some(k)` ⇒ 还要 `k` 的菜单权限。 - pub module_key: Option<&'static str>, - /// 列清单(**顺序 = react entity 的声明顺序** = 响应 JSON 的键序)。 - pub columns: &'static [ColumnSpec], - /// 需要 `::text` 投影的列(numeric 列 ⇒ JSON 必须是**字符串**)。 - /// - /// 🔴 **权威来源是 `col.numeric`**;`numeric_columns` 仅供检索与测试使用 - /// (`crud.rs` 的投影走 `col.numeric`,**不读本字段**)—— 本字段是同一事实的 - /// 第二份表示,靠 `numeric_columns_matches_column_flags` 维持一致。 - pub numeric_columns: &'static [&'static str], - /// 🔴 `f_creator_user_id` 的**写死值**(裁决 S22): - /// - `Some("admin")` ⇒ **完全不看 body**,恒写该值(demo 表的规则); - /// - `None` ⇒ `body.creatorUserId || 'admin'`(其余表)。 - /// - /// 🔴 **平台层不认 app_code**——「哪张表用哪条规则」是**业务知识** ⇒ 由业务 spec 自己声明, - /// 引擎只读本字段(⇒ 加一张新表不必改 `crud.rs`)。 - pub creator_fixed: Option<&'static str>, -} - -/// 一列的 spec。 -pub struct ColumnSpec { - /// 物理列名(`"f_title"`)。 - pub column: &'static str, - /// JSON 键(`"title"`)—— 必须是去前缀后的 camelCase。 - pub json_key: &'static str, - /// **路径 1** 新建时的默认值(`None` ⇒ 不给默认值 ⇒ NULL)。 - pub default: Option<&'static str>, - /// 是否 numeric(`true` ⇒ 投影 `::text` ⇒ JSON 字符串)。 - pub numeric: bool, -} diff --git a/src/backend/src/platform/envelope.rs b/src/backend/src/platform/envelope.rs deleted file mode 100644 index 5fbffff..0000000 --- a/src/backend/src/platform/envelope.rs +++ /dev/null @@ -1,224 +0,0 @@ -//! envelope —— `ActionResult{code,msg,data}` 统一信封。 -//! -//! 契约(**不得改动**,见 `docs/contract.md` §2 与 §1.2): -//! ```json -//! { "code": 200, "msg": "成功", "data": null } -//! ``` -//! -//! 🔴 **全仓只有这一种响应形状。** -//! - 业务失败(`400` 业务错 / `600` 未登录 / `403` 无菜单权限)**恒 HTTP 200**, -//! 成败只看 body 的 `code`。**禁止** 401/403 裸 body(那是 `tdc-rs` 的形状,不要抄)。 -//! - 唯一的**传输层**例外:未知路由 HTTP 404、方法不对 HTTP 405 —— 但 body 仍是本信封形状。 -//! - `data` 原样透传,不做包装;失败时恒为 `null`。 -//! -//! 本模块**只负责信封形状**,不负责 HTTP 状态码(那是 `routes.rs` 的 404/405 兜底中间件的活)。 - -use axum::Json; -use serde_json::Value; - -/// 全仓唯一的业务响应信封。 -/// -/// 🔴 **字段声明顺序 = JSON 键输出顺序**(`serde_json` 按结构体字段声明序序列化) -/// ⇒ 恒为 `{"code":…,"msg":…,"data":…}`,与 `docs/contract.md` §2 的示例逐字一致。 -#[derive(serde::Serialize)] -pub struct ActionResult { - /// 业务码:`200` 成功 / `400` 业务失败 / `600` 未登录 / `403` 无菜单权限。 - pub code: i32, - /// 业务提示文案。 - pub msg: String, - /// 业务数据;失败时恒为 `Value::Null`。 - pub data: Value, -} - -/// **业务码常量表** —— 官方 `ActionResultCode.java` 的逐字对应。 -/// -/// 🔴 **面 A 的码一个都不改**(`600` 未登录 / `403` 无菜单权限 / `400` 业务失败)—— -/// 这里只是把**官方码表**补齐,供**面 B**(官方 JNPF 契约面)引用。 -/// 面 B 的 `ok` / `fail` 语义与面 A **完全相同**(同一个信封、同样的「恒 HTTP 200」)。 -/// -/// 官方码表(`JNPF_SOURCE_AUDIT.md` §4): -/// - `200` SUCCESS / `400` FAIL / `401` VALIDATEERROR / `403` PEIMISSIONEXP / -/// `500` EXCEPTION / `600` SESSIONOVERDUE / `601` SESSIONOFFLINE / `602` SESSIONERROR。 -/// -/// 🔴 **面 B 无 token 必须返 `602`(不是 600)** —— 官方前端 `request.ts:78-80` -/// 只对 `601`/`602` 清 token ⇒ 只返 `600` 会让页面**卡住不跳登录**。 -pub mod code { - /// 成功。 - pub const SUCCESS: i32 = 200; - /// 业务失败(提示 `msg`)。 - pub const FAIL: i32 = 400; - /// 验证错误(官方 `VALIDATEERROR`)。 - pub const VALIDATE_ERROR: i32 = 401; - /// 权限异常(官方 `PEIMISSIONEXP`;本仓面 A 也用它表示「无菜单权限」)。 - pub const NO_PERMISSION: i32 = 403; - /// 服务端异常(官方 `EXCEPTION`)。 - pub const EXCEPTION: i32 = 500; - /// 登录过期(官方 `SESSIONOVERDUE`)—— **面 A 的「未登录」就是它**。 - pub const SESSION_OVERDUE: i32 = 600; - /// 被踢出(官方 `SESSIONOFFLINE`)。 - pub const SESSION_OFFLINE: i32 = 601; - /// token 失效(官方 `SESSIONERROR`)—— **面 B 的「未登录」必须是它**。 - pub const SESSION_ERROR: i32 = 602; -} - -/// 成功信封:`code=200`、`msg="成功"`、`data` **原样透传**(不做任何包装)。 -/// -/// 成功也允许 `data` 为 `Value::Null`(例如 `{"code":200,"msg":"成功","data":null}`)。 -pub fn ok(data: Value) -> Json { - Json(ActionResult { - code: 200, - msg: "成功".to_string(), - data, - }) -} - -/// 失败信封:`code=`、`msg=`、`data=null`。 -/// -/// 🔴 **恒 HTTP 200** —— 业务失败不是传输层错误,别在这里改状态码。 -/// `msg` 接受 `impl Into`(`&str` / `String` 都行)。 -pub fn fail(code: i32, msg: impl Into) -> Json { - Json(ActionResult { - code, - msg: msg.into(), - data: Value::Null, - }) -} - -#[cfg(test)] -mod tests { - use super::*; - - // ⚠️ `axum::Json` **没有** `Deref`/`Serialize` 实现(axum 0.8.9), - // 要拿内部结构体做 `serde_json::to_string` 必须解包 `.0`(`Json(pub T)`)。 - - /// `ok` ⇒ `code=200`、`msg="成功"`、`data` 原样透传(不做任何包装)。 - #[test] - fn ok_is_success_and_passes_data_through() { - let payload = serde_json::json!({ "id": "m1", "nested": [1, 2] }); - let j = ok(payload.clone()); - assert_eq!(j.0.code, 200); - assert_eq!(j.0.msg, "成功"); - assert_eq!(j.0.data, payload); - } - - /// 成功也可以没有数据 ⇒ `data` 仍是 `null`。 - #[test] - fn ok_with_null_data() { - let j = ok(Value::Null); - assert_eq!(j.0.code, 200); - assert_eq!(j.0.msg, "成功"); - assert_eq!(j.0.data, Value::Null); - } - - /// `fail(400, "x")` ⇒ `code=400`、`msg="x"`、`data` 恒为 `Value::Null`。 - #[test] - fn fail_400_carries_msg_and_null_data() { - let j = fail(400, "x"); - assert_eq!(j.0.code, 400); - assert_eq!(j.0.msg, "x"); - assert_eq!(j.0.data, Value::Null); - } - - /// `600`(未登录)/ `403`(无菜单权限)与 `400` **同形**:只是 `code`/`msg` 不同。 - #[test] - fn fail_600_and_403_have_the_same_shape() { - let unauthorized = fail(600, "未登录"); - assert_eq!(unauthorized.0.code, 600); - assert_eq!(unauthorized.0.msg, "未登录"); - assert_eq!(unauthorized.0.data, Value::Null); - - let forbidden = fail(403, "无菜单权限"); - assert_eq!(forbidden.0.code, 403); - assert_eq!(forbidden.0.msg, "无菜单权限"); - assert_eq!(forbidden.0.data, Value::Null); - } - - /// `fail` 的 `msg` 接受 `impl Into`:`&str` 与 `String` 都能用。 - #[test] - fn fail_accepts_both_str_and_string() { - assert_eq!(fail(400, "a").0.msg, "a"); - assert_eq!(fail(400, String::from("b")).0.msg, "b"); - } - - /// 🔴 **码表逐字钉死**(官方 `ActionResultCode.java`)—— 改了就是契约破。 - #[test] - fn code_table_matches_official_action_result_code() { - assert_eq!(code::SUCCESS, 200); - assert_eq!(code::FAIL, 400); - assert_eq!(code::VALIDATE_ERROR, 401); - assert_eq!(code::NO_PERMISSION, 403); - assert_eq!(code::EXCEPTION, 500); - assert_eq!(code::SESSION_OVERDUE, 600); - assert_eq!(code::SESSION_OFFLINE, 601); - assert_eq!(code::SESSION_ERROR, 602); - } - - /// 🔴 **面 A 的码不许被码表改动** —— 面 A 的「未登录」恒 `600`、「无权限」恒 `403`。 - #[test] - fn surface_a_codes_are_unchanged() { - assert_eq!(fail(600, "未登录").0.code, code::SESSION_OVERDUE); - assert_eq!(fail(403, "无菜单权限").0.code, code::NO_PERMISSION); - assert_eq!(fail(400, "x").0.code, code::FAIL); - } - - /// 🔴 JSON 键顺序必须是 `code` → `msg` → `data` - /// (`serde_json` 按结构体字段**声明序**输出 ⇒ 声明顺序不能改)。 - #[test] - fn serialized_key_order_is_code_msg_data() { - let ok_json = ok(Value::Null); - assert_eq!( - serde_json::to_string(&ok_json.0).unwrap(), - r#"{"code":200,"msg":"成功","data":null}"# - ); - - let fail_json = fail(400, "账号已存在:smoke_user"); - assert_eq!( - serde_json::to_string(&fail_json.0).unwrap(), - r#"{"code":400,"msg":"账号已存在:smoke_user","data":null}"# - ); - } - - /// 🔴 业务失败**恒 HTTP 200** —— 把 `fail()` 挂到真实 router 上,用裸 TCP 发一次请求验证状态码。 - /// (`docs/contract.md` §1.2 / §12 的验收点:业务失败是 HTTP 200,不是 4xx。) - #[tokio::test] - async fn fail_responds_with_http_200_and_envelope_body() { - use tokio::io::{AsyncReadExt, AsyncWriteExt}; - - let app = axum::Router::new().route( - "/boom", - axum::routing::get(|| async { fail(400, "账号已存在:smoke_user") }), - ); - - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let addr = listener.local_addr().unwrap(); - let server = tokio::spawn(async move { - axum::serve(listener, app).await.unwrap(); - }); - - let mut stream = tokio::net::TcpStream::connect(addr).await.unwrap(); - // 🔴 收发都套超时:没有超时的话,服务端不响应时这个测试会**永久挂住**而不是失败。 - let mut raw = Vec::new(); - tokio::time::timeout(std::time::Duration::from_secs(5), async { - stream - .write_all(b"GET /boom HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n") - .await - .unwrap(); - stream.read_to_end(&mut raw).await.unwrap(); - }) - .await - .expect("HTTP 往返超时(5s)——业务失败必须立刻返回 HTTP 200,不该挂住"); - server.abort(); - - let raw = String::from_utf8_lossy(&raw).to_string(); - let (head, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - assert!( - head.starts_with("HTTP/1.1 200 OK"), - "业务失败必须是 HTTP 200,实际响应头: {head}" - ); - - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 400); - assert_eq!(body["msg"], "账号已存在:smoke_user"); - assert_eq!(body["data"], Value::Null); - } -} diff --git a/src/backend/src/platform/guard.rs b/src/backend/src/platform/guard.rs deleted file mode 100644 index 43c713d..0000000 --- a/src/backend/src/platform/guard.rs +++ /dev/null @@ -1,344 +0,0 @@ -//! guard —— **生产档弱密钥守卫**(平台层,纯函数 + 一次库回读)。 -//! -//! 🔴 **本仓自定判据**,**不是**照抄兄弟项目 `tdc-rs` 的 `ProdGuard` —— -//! 那个守卫是 `tdc-rs` 的 **Java 上游真源**(`ssw.common.guard.ProdGuard`)的移植, -//! 本仓**没有**对应的上游(本仓的上游是 react 版 + 官方 JNPF Java,两者都不含这个守卫), -//! ⇒ 照抄过来只会得到「六条判据看着严,其实管的是别人的弱值面」。 -//! -//! **本仓的弱值面只有两处**: -//! 1. `SEED_ADMIN_PASSWORD`(env)—— 缺省 `123456`(契约 §8.6 的 admin 种子口令)。 -//! 🔴 这是本仓**唯一**的「拿到就能登录」的口令 ⇒ 生产档必须换掉。 -//! 2. `CIPHER_KEY` —— **协议共享值**(前端要用它加密口令)⇒ **故意不受管**(见下)。 -//! -//! 🔴 **协议共享值不受管**:`cipher.rs` 的 `CIPHER_KEY` 必须是 `md5_hex` 的**输入**, -//! 官方前端的 `cipher.ts` 用的是**同一个**常量 ⇒ 改它 ⇒ 前端加密出来的密文解不开 -//! ⇒ **整个登录链路当场报废**。它不是「忘了改的弱密钥」,它是**契约的一部分** -//! ⇒ 判据①(键不在本部署的清单里 ⇒ 跳过)在这里生效:本守卫的清单里**没有**它。 -//! -//! ## 档位 -//! -//! `SSW_PROFILE` env:`dev`(**缺省**)/ `prod`。 -//! - `dev`(缺省):**一律不判**(本仓的默认形态就是「本地开发/演示」), -//! ⇒ 契约与冒烟脚本**零影响**(种子口令恒 `123456`)。 -//! - `prod`:**下面六条判据逐条生效**,任一违规 ⇒ **拒绝启动**(人话报错 + `exit 1`)。 -//! -//! ## 六条判据(弱值判定,通用口径) -//! -//! ① **键不在本部署的清单里** ⇒ **跳过**(不判本部署根本没有的键)。 -//! ② 值为 `null` / 空白 ⇒ 违规。 -//! ③ 值**精确等于**已知弱值 ⇒ 违规。 -//! ④ 值**含**已知弱值 ⇒ 违规(**反绕过**:只比精确值时,`123456x` 能溜过去)。 -//! ⑤ 值命中**弱标记词**(**整体词**匹配,不是子串)⇒ 违规。 -//! ⑥ 长度 < [`MIN_LEN`] ⇒ 违规。 -//! -//! —— 并且:**强值必放行**(防「守卫恒红」:一条判据写错就再也起不来了)。 - -use crate::platform::db::Db; - -/// 生产档口令的**最小长度**(判据⑥)。 -pub const MIN_LEN: usize = 12; - -/// 部署档位。 -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Profile { - /// 开发/演示档(**缺省**)—— 弱值**不判**。 - Dev, - /// 生产档 —— 六条判据逐条生效。 - Prod, -} - -impl Profile { - /// 从 env 字符串解析档位(**非法值回落 `Dev`**,朝安全方向——不误伤本地开发)。 - /// - /// 接受 `prod` / `production`(大小写不敏感)⇒ [`Profile::Prod`]; - /// 其余(含空串、拼错)⇒ [`Profile::Dev`]。 - pub fn from_env_str(s: &str) -> Profile { - match s.trim().to_ascii_lowercase().as_str() { - "prod" | "production" => Profile::Prod, - _ => Profile::Dev, - } - } -} - -/// 已知弱值 —— **精确相等**即违规(判据③)。 -/// -/// 🔴 只收**本仓真会出现的**弱值:`123456` 是本仓的 admin 种子口令(契约 §8.6), -/// 其余是通用弱口令 ⇒ 换一份实现时**不必**改这里。 -pub const WEAK_EXACT: &[&str] = &[ - "123456", "admin", "admin123", "password", "changeme", "12345678", "111111", "000000", -]; - -/// 已知弱值 —— **包含**即违规(判据④,反绕过)。 -/// -/// 🔴 **只收「不作为更长单词子串出现」的 token**:`admin` 不在里面 -/// (`administrator` 含 `admin` ⇒ 会误伤);`password` 在里面 -/// (`password123` 必是弱值)。 -pub const WEAK_CONTAINS: &[&str] = &["123456", "changeme", "password", "qwerty", "letmein"]; - -/// 弱标记词 —— **整体词**命中即违规(判据⑤)。 -/// -/// 匹配口径:把值按**非字母数字**切成词,逐词**全等**比较 ⇒ -/// `demo-2024` 命中 `demo`;`demonstration` **不**命中(那是一个整词 `demonstration`)。 -pub const WEAK_MARKER_WORDS: &[&str] = &[ - "demo", "test", "example", "sample", "default", "admin", "guest", "user", "temp", -]; - -/// 一条违规(**点名**是哪个键、哪条判据 ⇒ 报错能直接指向要改什么)。 -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Violation { - /// 违规的键名。 - pub key: String, - /// 违规原因(人话,含判据编号)。 - pub reason: String, -} - -impl std::fmt::Display for Violation { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}:{}", self.key, self.reason) - } -} - -/// 把值按**非字母数字**切成词(判据⑤的分词口径)。 -fn words_of(value: &str) -> Vec { - value - .split(|c: char| !c.is_alphanumeric()) - .filter(|w| !w.is_empty()) - .map(|w| w.to_ascii_lowercase()) - .collect() -} - -/// 判定**单个**值是否弱(返回全部违规原因;空 vec = 通过)。 -/// -/// 🔴 **纯函数**(不读 env、不读库、不看全局状态)⇒ 可单测、可在别处复用。 -/// -/// 🔴 判据③ 只比**精确相等**(大小写不敏感);判据④ 比**包含**(大小写不敏感)。 -pub fn weak_reasons(value: &str) -> Vec { - let mut reasons = Vec::new(); - let trimmed = value.trim(); - - // ② 空 / 空白 - if trimmed.is_empty() { - reasons.push("判据②:值为空/空白".to_string()); - // 空值也必然过不了 ⑥,但只报一次 ⇒ 直接返回。 - return reasons; - } - - let lower = trimmed.to_ascii_lowercase(); - - // ③ 精确等于已知弱值 - if WEAK_EXACT.iter().any(|w| lower == w.to_ascii_lowercase()) { - reasons.push(format!("判据③:值等于已知弱值({trimmed})")); - } - - // ④ 包含已知弱值(反绕过) - if let Some(hit) = WEAK_CONTAINS - .iter() - .find(|w| lower.contains(&w.to_ascii_lowercase())) - { - reasons.push(format!("判据④:值包含已知弱值({hit})")); - } - - // ⑤ 命中弱标记词(整体词) - let words = words_of(trimmed); - if let Some(hit) = WEAK_MARKER_WORDS - .iter() - .find(|w| words.iter().any(|word| word == &w.to_ascii_lowercase())) - { - reasons.push(format!("判据⑤:值命中弱标记词({hit})")); - } - - // ⑥ 长度下限 - if trimmed.chars().count() < MIN_LEN { - reasons.push(format!( - "判据⑥:长度 {} < {MIN_LEN}", - trimmed.chars().count() - )); - } - - reasons -} - -/// 判定**单个**值是否弱(只看是否违规,不看原因)。 -pub fn is_weak(value: &str) -> bool { - !weak_reasons(value).is_empty() -} - -/// 生产档的**配置级**守卫:逐个键判,返回全部违规。 -/// -/// 🔴 **键不在清单里 ⇒ 不判**(判据①):调用方只把「本部署真有的键」放进来。 -/// -/// - `values` = 本部署真实存在的键值对(如 `[(键名, 值)]`)。 -pub fn check_values(values: &[(String, String)]) -> Vec { - let mut out = Vec::new(); - for (key, value) in values { - for reason in weak_reasons(value) { - out.push(Violation { - key: key.clone(), - reason, - }); - } - } - out -} - -/// 把违规渲染成人话(**点名键 + 原因**),供启动失败时打印。 -pub fn render_violations(violations: &[Violation]) -> String { - let mut s = String::new(); - for (i, v) in violations.iter().enumerate() { - if i > 0 { - s.push('\n'); - } - s.push_str(" - "); - s.push_str(&v.to_string()); - } - s -} - -/// 🔴 **库内**校验:admin 账号当前的口令**是不是已知弱值**(生产档)。 -/// -/// 🔴 **为什么必须回读库里那行**:种子口令只对**空库**生效(`first_seed` 仅当 -/// `base_user` 行为 0 时跑)⇒ 生产库里 admin 的口令可能是**当初**种下的 -/// `123456`,而运维**后来**才设了 `SEED_ADMIN_PASSWORD` ⇒ -/// **配置看着是强的、库里其实是弱的** ⇒ 只查配置 = 守卫形同虚设。 -/// -/// 🔴 **为什么只比「已知弱值」而不是比「配置里那个」**:管理员**合法**在界面上 -/// 改过口令后,库里那个自然不等于配置里那个 ⇒ 若拿配置去比, -/// **每次改完口令都得改配置**,否则服务起不来 ⇒ 那是误伤。 -/// 本守卫只回答「这个口令是不是**人人皆知的弱口令**」⇒ 改过口令 ⇒ 放行; -/// 还是默认的 `123456` ⇒ 拦。 -/// -/// - `db`:库句柄。 -/// -/// 返回 `Ok(())` = 通过;`Err(msg)` = 人话错误。 -pub async fn verify_stored_admin_password(db: &Db) -> Result<(), String> { - let rows = db - .query_json( - "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"password\" \ - FROM base_user WHERE f_is_administrator = 1 ORDER BY f_id LIMIT 1", - ) - .await - .map_err(|e| format!("读取 admin 行失败: {e}"))?; - - let Some(row) = rows.first() else { - // 没有 admin 行 ⇒ 不是「弱口令」,是「没建账号」⇒ 不归本守卫管。 - return Ok(()); - }; - - let stored = row["password"].as_str().unwrap_or_default(); - if stored.is_empty() { - return Err("admin 行的 f_password 为空 ⇒ 无法校验(请在管理界面重置口令)".to_string()); - } - - // 库里存的是 md5(明文) ⇒ 拿每个弱值的 md5 去比。 - for weak in WEAK_EXACT { - if stored.eq_ignore_ascii_case(&crate::platform::cipher::md5_hex(weak)) { - return Err(format!( - "admin 账号的库内口令仍是**已知弱口令**({weak})—— \ - 种子口令只对空库生效,库里是当初种下的那个。\ - 请在管理界面重置 admin 口令,或清库重来。" - )); - } - } - Ok(()) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn reasons(v: &str) -> Vec { - weak_reasons(v) - } - - /// ⑥ 长度下限:短的 ⇒ 违规,长的 ⇒ 不因长度违规。 - #[test] - fn min_len_is_enforced() { - assert!(reasons("short1A!").iter().any(|r| r.contains("判据⑥"))); - assert!(!reasons("Xk9mQ2vL7pR4zW8").iter().any(|r| r.contains("判据⑥"))); - } - - /// ③ 精确弱值 ⇒ 违规。 - #[test] - fn exact_weak_value_is_blocked() { - assert!(reasons("123456").iter().any(|r| r.contains("判据③"))); - assert!(reasons("admin").iter().any(|r| r.contains("判据③"))); - } - - /// ④ **反绕过**:默认口令加个后缀 ⇒ 仍然违规。 - #[test] - fn weak_value_with_suffix_is_blocked() { - assert!(reasons("123456x").iter().any(|r| r.contains("判据④"))); - } - - /// ④ 不得误伤 `administrator`(`admin` 只在**精确**与**整体词**两条里)。 - #[test] - fn administrator_is_not_a_false_positive() { - let rs = reasons("administrator9Q!x"); - assert!( - !rs.iter().any(|r| r.contains("判据④")), - "administrator 不该命中判据④:{rs:?}" - ); - } - - /// ⑤ 弱标记词:**整体词**命中,不是子串。 - /// - /// 🔴 分词口径 = 按**非字母数字**切 ⇒ `demo-2024` 是两个词(`demo` 命中), - /// 而 `demo2024` 是**一个词**(`demo` 不命中)——这是「整体词」的设计后果, - /// 避免 `administrator` / `demonstration` 这类正常词被误伤。 - #[test] - fn marker_word_is_whole_word_only() { - assert!(reasons("demo-2024Q!x").iter().any(|r| r.contains("判据⑤"))); - assert!(!reasons("demonstration9Q!x") - .iter() - .any(|r| r.contains("判据⑤"))); - } - - /// 🔴 `demo2024` 这类**连写**的弱口令:⑤ 不命中(整体词),但 **⑥ 长度**兜住。 - /// - /// ⇒ 钉住「六条判据是**并集**,不是各自独立」:任一条命中即违规。 - #[test] - fn joined_marker_is_caught_by_the_length_rule() { - let rs = reasons("demo2024Q!x"); - assert!( - !rs.iter().any(|r| r.contains("判据⑤")), - "连写的 demo2024 不该命中整体词判据:{rs:?}" - ); - assert!( - rs.iter().any(|r| r.contains("判据⑥")), - "但它必须被长度判据兜住:{rs:?}" - ); - } - - /// ② 空值 ⇒ 违规。 - #[test] - fn blank_value_is_named() { - assert!(reasons(" ").iter().any(|r| r.contains("判据②"))); - } - - /// 🔴 **强值必放行**(防「守卫恒红」)。 - #[test] - fn strong_value_is_allowed() { - assert!(reasons("Xk9mQ2vL7pR4zW8").is_empty()); - assert!(!is_weak("Xk9mQ2vL7pR4zW8")); - } - - /// 档位解析:非法值回落 `Dev`(不误伤本地开发)。 - #[test] - fn profile_parses_leniently() { - assert_eq!(Profile::from_env_str("prod"), Profile::Prod); - assert_eq!(Profile::from_env_str("PRODUCTION"), Profile::Prod); - assert_eq!(Profile::from_env_str("prod "), Profile::Prod); - assert_eq!(Profile::from_env_str("dev"), Profile::Dev); - assert_eq!(Profile::from_env_str(""), Profile::Dev); - assert_eq!(Profile::from_env_str("productionn"), Profile::Dev); - } - - /// 守卫报错**点名键**(运维要能直接照着改)。 - #[test] - fn violation_message_names_the_key() { - let vs = check_values(&[("SEED_ADMIN_PASSWORD".to_string(), "123456".to_string())]); - assert!(!vs.is_empty()); - assert_eq!(vs[0].key, "SEED_ADMIN_PASSWORD"); - assert!(render_violations(&vs).contains("SEED_ADMIN_PASSWORD")); - } -} diff --git a/src/backend/src/platform/ids.rs b/src/backend/src/platform/ids.rs deleted file mode 100644 index 4f72293..0000000 --- a/src/backend/src/platform/ids.rs +++ /dev/null @@ -1,54 +0,0 @@ -//! ids —— 主键生成(36 位 UUID v4)。 -//! -//! 契约:规格 §「主键是 36 位 UUID v4(带连字符)」。 -//! -//! 🔴 **不是** `tdc-rs` 的雪花十进制 —— 本仓的 `f_id` 存 `varchar(50)`,形状必须与 -//! 官方 JNPF 的 `varchar(50)` UUID 一致,迁移期靠 `--data-only` 导数据。 - -use uuid::Uuid; - -/// 生成 36 位 UUID v4(带连字符,形如 `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`)。 -/// -/// 标准布局:第 9/14/19/24 位(1-based)是连字符,**版本号 `4` 紧跟在第二个连字符之后** -/// (0-based 下标 14 / 1-based 第 15 位)。 -pub fn new_uuid() -> String { - Uuid::new_v4().to_string() -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 36 位 + 连字符位置 + 版本号 `4`。 - /// - /// 标准布局 `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`(1-based): - /// 连字符在第 9 / 14 / 19 / 24 位,版本号 `4` 在**第 15 位**(紧跟第 14 位的连字符)。 - /// ⚠️ 任务书把这两个下标写反了(写成「第 14 位是 `4`、第 15 位是 `-`」); - /// 真实 UUID 里 `4` 必在连字符**之后**,所以这里按真实布局钉死。 - #[test] - fn new_uuid_shape() { - let u = new_uuid(); - assert_eq!(u.len(), 36, "36 位 UUID(带连字符)"); - assert_eq!(&u[8..9], "-", "第 9 位(1-based)是连字符"); - assert_eq!(&u[13..14], "-", "第 14 位(1-based)是连字符"); - assert_eq!(&u[18..19], "-", "第 19 位(1-based)是连字符"); - assert_eq!(&u[23..24], "-", "第 24 位(1-based)是连字符"); - // 版本号 v4 ⇒ 下标 14 必是 '4'(0-based)/ 第 15 位(1-based)。 - assert_eq!(&u[14..15], "4", "版本号必须是 4"); - // 连字符之外全是小写 hex。 - assert!( - u.chars() - .enumerate() - .all(|(i, c)| matches!(i, 8 | 13 | 18 | 23) || c.is_ascii_hexdigit()), - "除连字符外必须是 hex 字符:{u}" - ); - } - - /// 两次调用必不相同(v4 随机性)。 - #[test] - fn new_uuid_is_unique() { - let a = new_uuid(); - let b = new_uuid(); - assert_ne!(a, b, "两次生成不得相同"); - } -} diff --git a/src/backend/src/platform/jnpf.rs b/src/backend/src/platform/jnpf.rs deleted file mode 100644 index d755187..0000000 --- a/src/backend/src/platform/jnpf.rs +++ /dev/null @@ -1,948 +0,0 @@ -//! jnpf —— **面 B**(官方 JNPF 契约面)的端点与响应形状。 -//! -//! 规格:`JNPF_COMPAT_SURFACE.md`(§2.2 判别头 / §3 端点 / §4 码表 / §8 已知错位)。 -//! 官方真源:`~/Desktop/workspace/jnpf/`(Java 后端 + `jnpf-web-apps-main` 官方前端)。 -//! -//! 🔴 **面 A 一个字都不动** —— 本模块只**新增**官方形状的端点; -//! 与面 A 共用的路由(`CurrentUser` / `Authority/Data`)按**判别头**分流。 -//! -//! 🔴 **判别头 = `Vue-Version: 3`**: -//! - 官方前端 `jnpf-web-apps-main/src/api/request.ts:109-112` **无条件**携带 `Vue-Version: 3`; -//! - 本仓前端 `src/frontend/src/api/request.ts:35-37` **从不**携带 ⇒ **零歧义**。 -//! - `App-Code` / `Jnpf-Origin` **不作**判据(本仓前端**也**发这两个 ⇒ 判了必错)。 -//! -//! 🔴 **面 B 的「未登录」必须返 `602`(不是 600)** —— 官方前端 -//! `ResultEnum`(`jnpf-web-monorepo-framework/.../request-client/enum.ts`)只对 -//! `601`(TOKEN_LOGGED)/ `602`(TOKEN_ERROR)清 token ⇒ 返 `600` 会让页面卡住不跳登录。 -//! -//! 🔴 **点权限判据 = `base_module.f_en_code`**(官方 `@SaCheckPermission("permission.user")`), -//! 与面 A 的「菜单路径 `f_url_address`」是**两套并存**的判据,互不影响。 - -use std::collections::{HashMap, HashSet}; - -use axum::body::Bytes; -use axum::extract::{Path, RawQuery, State}; -use axum::http::HeaderMap; -use axum::Json; -use serde_json::{json, Value}; - -use crate::platform::auth::{require_login_jnpf, resolve_user}; -use crate::platform::db::{pglite, pglite::ToSql, Db}; -use crate::platform::envelope::{code, fail, ok, ActionResult}; -use crate::platform::permission::{has_en_code_permission, resolve_user_module_ids}; -use crate::platform::session::TokenUser; -use crate::platform::state::AppState; - -// ---------------------------------------------------------------- 判别头 - -/// 🔴 **判别头名**(HTTP 头名大小写不敏感 ⇒ 这里用小写)。 -const VUE_VERSION: &str = "vue-version"; - -/// 🔴 **判别头的值** —— 官方前端固定发 `3`。 -const VUE_VERSION_VALUE: &str = "3"; - -/// 本仓的系统 id(`currentSystemId` / `userInfo.systemId` / 菜单 `systemId` 的兜底值)。 -pub const SYSTEM_ID: &str = "ssw-jnpf-lite-rust"; - -/// 本仓的系统编码(`userInfo.systemCode`)。 -pub const SYSTEM_CODE: &str = "ssw-jnpf-lite-rust"; - -// ---------------------------------------------------------------- 官方点权限码 - -/// `@SaCheckPermission("permission.user")`。 -const EN_USER: &str = "permission.user"; -/// `@SaCheckPermission("permission.role")`。 -const EN_ROLE: &str = "permission.role"; -/// `@SaCheckPermission("permission.organize")`。 -const EN_ORGANIZE: &str = "permission.organize"; -/// `@SaCheckPermission("permission.menu")`。 -const EN_MENU: &str = "permission.menu"; - -/// 菜单树的最大层数(防御 `f_parent_id` 被改成人为环时的无限递归)。 -const MAX_TREE_DEPTH: usize = 32; - -/// 🔴 **这个请求是不是「面 B」** —— 判别头 `Vue-Version: 3`。 -/// -/// **唯一的全局判别规则**(`JNPF_COMPAT_SURFACE.md` §2.2): -/// ```text -/// 请求头含 "Vue-Version: 3" ⇒ 走【面 B】官方形状 -/// 否则 ⇒ 走【面 A】ssw 形状 -/// ``` -pub fn is_jnpf(headers: &HeaderMap) -> bool { - headers - .get(VUE_VERSION) - .and_then(|v| v.to_str().ok()) - .map(|v| v.trim() == VUE_VERSION_VALUE) - .unwrap_or(false) -} - -// ---------------------------------------------------------------- 通用小工具 - -/// DB 报错 ⇒ 面 B 的 `500`(官方 `EXCEPTION`);真因只进服务端日志,**不外泄**。 -fn db_error(e: pglite::Error, ctx: &str) -> Json { - eprintln!("[jnpf] {ctx}失败: {e}"); - fail(code::EXCEPTION, "系统异常,请联系管理员") -} - -/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`。 -/// -/// 🔴 **不用 axum 的 `Json`**:它的解析失败会返回 **422 + 非信封 body** ⇒ 契约破。 -fn parse_body(body: &Bytes) -> Result> { - match serde_json::from_slice::(body) { - Ok(v) => Ok(v), - Err(_) => Err(fail(code::FAIL, "请求参数格式错误")), - } -} - -/// 分页参数(官方 `Pagination.java`:`pageSize` 默认 `20` / `currentPage` 默认 `1`)。 -struct Paging { - current_page: i64, - page_size: i64, - offset: i64, -} - -impl Paging { - /// 从 query 取分页参数;**缺失 / 非法 ⇒ 用官方默认值**(不报错)。 - fn of(raw: &RawQuery) -> Self { - let current_page = crate::platform::sys::query_param(raw, "currentPage") - .trim() - .parse::() - .unwrap_or(1) - .max(1); - // 🔴 `pageSize` 夹在 `[1, 1000]` —— 防「pageSize=0」把 SQL 打成语法错、 - // 防超大值把整表拉进内存。 - let page_size = crate::platform::sys::query_param(raw, "pageSize") - .trim() - .parse::() - .unwrap_or(20) - .clamp(1, 1000); - Self { - current_page, - page_size, - offset: (current_page - 1) * page_size, - } - } -} - -/// 官方 `PageListVO` —— `{pagination:{currentPage,pageSize,total}, list:[…]}`。 -/// -/// 🔴 **`data` 必须是对象**(不是裸数组)—— 官方 `PageListVO` 有 `pagination` + `list` 两个字段。 -fn page_list(current_page: i64, page_size: i64, total: i64, list: Vec) -> Value { - json!({ - "pagination": { - "currentPage": current_page, - "pageSize": page_size, - "total": total, - }, - "list": list, - }) -} - -/// 官方 `ListVO` —— `{list:[…]}`(**只有 `list` 一个字段**)。 -fn list_vo(list: Vec) -> Value { - json!({ "list": list }) -} - -/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 -fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { - values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() -} - -/// 面 B 的守卫:**登录(602)** + **点权限(`f_en_code` ⇒ 403)**。 -async fn guard( - state: &AppState, - headers: &HeaderMap, - en_code: &str, -) -> Result> { - let user = require_login_jnpf(state, headers).await?; - if has_en_code_permission(&state.db, &user.user_id, user.is_admin, en_code).await { - Ok(user) - } else { - Err(fail(code::NO_PERMISSION, "无权限")) - } -} - -// ---------------------------------------------------------------- 菜单(AllMenuSelectVO) - -/// 一行菜单(`AllMenuSelectVO` 那 15 个字段的原料)。 -struct MenuRow { - id: String, - full_name: String, - en_code: Option, - parent_id: String, - icon: Option, - url_address: Option, - page_address: Option, - link_target: Option, - menu_type: i64, - property_json: Option, - sort_code: i64, - system_id: Option, - is_data: bool, -} - -/// 菜单投影(面 B 专用)—— 🔴 **显式列出每一列并加 `AS ""` 别名** -/// (PG 会把未加引号的标识符折叠成小写 ⇒ `row_to_json` 的键会变样且**静默**)。 -const MENU_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ - f_en_code AS \"enCode\", COALESCE(f_parent_id, '0') AS \"parentId\", \ - f_icon AS \"icon\", f_url_address AS \"urlAddress\", \ - f_page_address AS \"pageAddress\", f_link_target AS \"linkTarget\", \ - COALESCE(f_type, 2) AS \"type\", f_property_json AS \"propertyJson\", \ - COALESCE(f_sort_code, 0) AS \"sortCode\", f_system_id AS \"systemId\", \ - COALESCE(f_is_data_authorize, 0) AS \"isData\""; - -/// 读当前用户**可见**的菜单行(未软删 + 四源合并过滤)。 -/// -/// 🔴 非管理员的可见集合来自 `resolve_user_module_ids`(四源合并:直授/角色/组织/岗位), -/// 与面 A 的 `build_menu_list` **同一套判据** ⇒ 两个面看到的菜单集合一致。 -async fn load_menus(db: &Db, user_id: &str, is_admin: i32) -> Vec { - let sql = format!( - "SELECT {MENU_PROJECTION} FROM base_module WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC, f_full_name ASC" - ); - let rows = match db.query_json(&sql).await { - Ok(rows) => rows, - Err(e) => { - eprintln!("[jnpf] 菜单查询失败(按空菜单处理): {e}"); - return Vec::new(); - } - }; - let mut items: Vec = rows.iter().filter_map(parse_menu_row).collect(); - if is_admin != 1 { - let visible = resolve_user_module_ids(db, user_id).await; - items.retain(|m| visible.contains(&m.id)); - } - items -} - -/// 一行 JSON ⇒ [`MenuRow`]。 -fn parse_menu_row(row: &Value) -> Option { - let id = row["id"].as_str()?.to_string(); - if id.is_empty() { - return None; - } - Some(MenuRow { - id, - full_name: row["fullName"].as_str().unwrap_or_default().to_string(), - en_code: row["enCode"].as_str().map(str::to_string), - // 🔴 react: `parentId: m.parentId || '0'` —— 空 ⇒ `'0'`。 - parent_id: match row["parentId"].as_str() { - Some(p) if !p.is_empty() => p.to_string(), - _ => "0".to_string(), - }, - icon: row["icon"].as_str().map(str::to_string), - url_address: row["urlAddress"].as_str().map(str::to_string), - page_address: row["pageAddress"].as_str().map(str::to_string), - link_target: row["linkTarget"].as_str().map(str::to_string), - menu_type: row["type"].as_i64().unwrap_or(2), - property_json: row["propertyJson"].as_str().map(str::to_string), - sort_code: row["sortCode"].as_i64().unwrap_or(0), - system_id: row["systemId"].as_str().map(str::to_string), - is_data: row["isData"].as_i64().unwrap_or(0) != 0, - }) -} - -/// `f_property_json`(TEXT)⇒ JSON 值;空 / 非法 ⇒ `null`。 -fn parse_property_json(raw: Option<&str>) -> Value { - let Some(text) = raw else { - return Value::Null; - }; - let trimmed = text.trim(); - if trimmed.is_empty() { - return Value::Null; - } - serde_json::from_str::(trimmed).unwrap_or(Value::Null) -} - -/// 一个菜单节点 ⇒ 官方 `AllMenuSelectVO`(**15 个字段,一个不少**)。 -/// -/// 🔴 **键名与顺序照官方 `AllMenuSelectVO.java:12-50`**(`id` / `fullName` / `enCode` / -/// `parentId` / `icon` / `hasChildren` / `urlAddress` / `pageAddress` / `linkTarget` / -/// `children` / `type` / `propertyJson` / `sortCode` / `systemId` / `isData`)。 -fn menu_value(row: MenuRow, children: Vec, has_children: bool) -> Value { - let MenuRow { - id, - full_name, - en_code, - parent_id, - icon, - url_address, - page_address, - link_target, - menu_type, - property_json, - sort_code, - system_id, - is_data, - } = row; - json!({ - "id": id, - "fullName": full_name, - "enCode": en_code, - "parentId": parent_id, - "icon": icon, - "hasChildren": has_children, - "urlAddress": url_address, - "pageAddress": page_address, - "linkTarget": link_target, - "children": children, - "type": menu_type, - "propertyJson": parse_property_json(property_json.as_deref()), - "sortCode": sort_code, - // 🔴 种子菜单的 `f_system_id` 是 NULL ⇒ 兜底成本仓系统 id(单系统)。 - "systemId": system_id - .filter(|s| !s.trim().is_empty()) - .unwrap_or_else(|| SYSTEM_ID.to_string()), - "isData": is_data, - }) -} - -/// 建菜单树(根 = `parentId` 为空 / `'0'` / **父不在可见集合内**)。 -fn build_menu_tree(rows: Vec) -> Vec { - let visible: HashSet = rows.iter().map(|m| m.id.clone()).collect(); - let mut by_parent: HashMap> = HashMap::new(); - let mut roots: Vec = Vec::new(); - for row in rows { - if row.parent_id != "0" && visible.contains(&row.parent_id) { - by_parent.entry(row.parent_id.clone()).or_default().push(row); - } else { - roots.push(row); - } - } - roots - .into_iter() - .map(|row| menu_node(row, &mut by_parent, 0)) - .collect() -} - -/// 递归建一棵子树。 -fn menu_node( - row: MenuRow, - by_parent: &mut HashMap>, - depth: usize, -) -> Value { - // 防御:`f_parent_id` 被改成人为环时不要无限递归(层数封顶 ⇒ 截断)。 - let children: Vec = if depth >= MAX_TREE_DEPTH { - Vec::new() - } else { - by_parent - .remove(&row.id) - .unwrap_or_default() - .into_iter() - .map(|child| menu_node(child, by_parent, depth + 1)) - .collect() - }; - let has_children = !children.is_empty(); - menu_value(row, children, has_children) -} - -/// 官方 `PermissionModel` 列表 —— **每个可见菜单一条**。 -/// -/// 🔴 **官方语义**:`modelId` = **菜单 id** -/// (官方前端 `views/common/dynamicModel/list/index.vue:739`: -/// `permissionList.find(o => o.modelId === searchInfo.menuId)`) -/// ⇒ 本仓按「菜单」给一条,`moduleName` = 菜单全名。 -/// -/// 🔴 `button` / `column` / `resource` / `form` **恒为空数组** —— 本仓**不实现** -/// 按钮级权限(`base_module_button` / `_column` / `_form` / `_data` 都不做) -/// ⇒ 官方前端的按钮会被过滤掉(**已知限制 B4**,`docs/known-limitations.md` §H)。 -fn build_permission_list(rows: &[MenuRow]) -> Vec { - rows.iter() - .map(|m| { - json!({ - "modelId": m.id, - "moduleName": m.full_name, - "button": [], - "column": [], - "resource": [], - "form": [], - }) - }) - .collect() -} - -// ---------------------------------------------------------------- CurrentUser(PcUserVO) - -/// `GET /api/oauth/CurrentUser` 的**面 B**分支 —— 官方 `PcUserVO` 形状。 -/// -/// 🔴 **顶层五个字段一个都不能少**(官方前端 `store/auth.ts:121` 逐个取用): -/// `menuList` / `permissionList` / `userInfo` / `currentSystemId` / `sysConfigInfo`。 -/// -/// 🔴 未登录 ⇒ **`602`**(官方前端只对 `601`/`602` 清 token ⇒ 返 `600` 会卡住不跳登录)。 -pub async fn current_user(state: &AppState, headers: &HeaderMap) -> Json { - let Some(user) = resolve_user(state, headers) else { - return fail(code::SESSION_ERROR, "登录状态已失效,请重新登录"); - }; - - let menus = load_menus(&state.db, &user.user_id, user.is_admin).await; - let permission_list = build_permission_list(&menus); - let menu_list = build_menu_tree(menus); - let user_info = build_user_info(&state.db, &user).await; - - ok(json!({ - "menuList": menu_list, - "permissionList": permission_list, - "userInfo": user_info, - "currentSystemId": SYSTEM_ID, - // 🔴 `sysConfigInfo` 返 **空对象**(不是 null)⇒ 官方前端 `baseStore.setSysConfig` 不炸。 - "sysConfigInfo": {}, - })) -} - -/// 官方 `UserCommonInfoVO`(15 个字段)。 -/// -/// 🔴 `isAdministrator` 在这里是 **布尔**(官方 `UserCommonInfoVO.java:75` 是 `Boolean`)—— -/// 而**列表项**里它是**数字**(官方 `UserListVO.java:60` 是 `Integer`)⇒ 两处**故意不同**。 -async fn build_user_info(db: &Db, user: &TokenUser) -> Value { - let rows = match db - .query_json_params( - "SELECT f_real_name AS \"realName\", f_head_icon AS \"headIcon\", \ - f_organize_id AS \"organizeId\", f_position_id AS \"positionId\", \ - (EXTRACT(EPOCH FROM f_prev_log_time) * 1000)::bigint AS \"prevLoginTime\", \ - f_prev_log_ip AS \"prevLoginIp\" \ - FROM base_user WHERE f_id = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&user.user_id], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - eprintln!("[jnpf] 读用户信息失败: {e}"); - Vec::new() - } - }; - let row = rows.first(); - let real_name = row - .and_then(|r| r["realName"].as_str()) - .filter(|s| !s.is_empty()) - .unwrap_or(user.account.as_str()) - .to_string(); - let head_icon = row.and_then(|r| r["headIcon"].as_str()).map(str::to_string); - let organize_id = row - .and_then(|r| r["organizeId"].as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string); - let position_id = row - .and_then(|r| r["positionId"].as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string); - let prev_login_time = row.and_then(|r| r["prevLoginTime"].as_i64()); - let prev_login_ip = row - .and_then(|r| r["prevLoginIp"].as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string); - let organize_name = match organize_id.as_deref() { - Some(id) => organize_name_of(db, id).await, - None => None, - }; - - json!({ - "userId": user.user_id, - "userAccount": user.account, - "userName": real_name, - "headIcon": head_icon, - "organizeId": organize_id, - "organizeName": organize_name, - "positionId": position_id, - // 🔴 本仓**没有**岗位表(`base_position` 不在 v1 范围)⇒ 恒 `null`。 - "positionName": Value::Null, - "systemId": SYSTEM_ID, - "systemCode": SYSTEM_CODE, - // 🔴 官方 `prevLogin`:1 = 上次登录 / 2 = 本次登录。本仓不区分 ⇒ 恒 1。 - "prevLogin": 1, - "prevLoginTime": prev_login_time, - "prevLoginIPAddress": prev_login_ip, - "prevLoginIPAddressName": Value::Null, - "isAdministrator": user.is_admin == 1, - }) -} - -/// 机构名(查不到 ⇒ `None`)。 -async fn organize_name_of(db: &Db, id: &str) -> Option { - let rows = match db - .query_json_params( - "SELECT f_full_name AS \"fullName\" FROM base_organize \ - WHERE f_id = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&id], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - eprintln!("[jnpf] 读机构名失败: {e}"); - return None; - } - }; - rows.first() - .and_then(|r| r["fullName"].as_str()) - .map(str::to_string) -} - -// ---------------------------------------------------------------- 用户列表 - -/// `GET /api/permission/Users` —— 官方 `UserController.java:295` 的形状。 -/// -/// 🔴 **硬性要求**(`JNPF_COMPAT_SURFACE.md` §3.2): -/// 1. `data` 是**对象**(`pagination` + `list`),**不是**裸数组; -/// 2. 列表项**不含** `password` / `secretkey`(投影里根本不选那两列); -/// 3. `pagination.total` = **总条数**; -/// 4. `currentPage` / `pageSize` **原样回显**; -/// 5. `creatorTime` 是**毫秒时间戳(数字)**; -/// 6. `isAdministrator` 是**数字** `0|1`(官方 `UserListVO.java:60` 是 `Integer`)。 -pub async fn users_list( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = guard(&state, &headers, EN_USER).await { - return resp; - } - let page = Paging::of(&raw); - - let total = match state - .db - .scalar_text("SELECT count(*) FROM base_user WHERE f_delete_mark = 0") - .await - { - Ok(Some(t)) => t.trim().parse::().unwrap_or(0), - Ok(None) => 0, - Err(e) => return db_error(e, "用户总数查询"), - }; - - let limit = Some(page.page_size.to_string()); - let offset = Some(page.offset.to_string()); - let values = [limit, offset]; - let params = params_of(&values); - let rows = match state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \ - f_real_name AS \"fullName\", f_gender AS \"gender\", \ - f_mobile_phone AS \"mobilePhone\", f_email AS \"email\", \ - f_organize_id AS \"organize\", f_description AS \"description\", \ - COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ - (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\", \ - COALESCE(f_sort_code, 0) AS \"sortCode\", \ - COALESCE(f_lock_mark, 0) AS \"lockMark\", \ - COALESCE(f_handover_mark, 0) AS \"handoverMark\", \ - COALESCE(f_is_administrator, 0) AS \"isAdministrator\", \ - f_head_icon AS \"headIcon\", f_unlock_time AS \"unlockTime\", \ - f_position_id AS \"position\", 0 AS \"isDutyUser\", \ - NULL::text AS \"maxRelationId\" \ - FROM base_user WHERE f_delete_mark = 0 \ - ORDER BY f_creator_time DESC, f_id ASC \ - LIMIT $1::text::integer OFFSET $2::text::integer", - ¶ms, - ) - .await - { - Ok(rows) => rows, - Err(e) => return db_error(e, "用户列表查询"), - }; - - ok(page_list(page.current_page, page.page_size, total, rows)) -} - -// ---------------------------------------------------------------- 角色列表 - -/// `GET /api/permission/Role` —— 官方 `RoleController.java:99-100` 的形状(PageListVO)。 -pub async fn roles_list( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = guard(&state, &headers, EN_ROLE).await { - return resp; - } - let page = Paging::of(&raw); - - let total = match state - .db - .scalar_text("SELECT count(*) FROM base_role WHERE f_delete_mark = 0") - .await - { - Ok(Some(t)) => t.trim().parse::().unwrap_or(0), - Ok(None) => 0, - Err(e) => return db_error(e, "角色总数查询"), - }; - - let limit = Some(page.page_size.to_string()); - let offset = Some(page.offset.to_string()); - let values = [limit, offset]; - let params = params_of(&values); - let rows = match state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ - f_type AS \"type\", f_description AS \"description\", \ - COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ - COALESCE(f_sort_code, 0) AS \"sortCode\", \ - (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\", \ - COALESCE(f_delete_mark, 0) AS \"deleteMark\" \ - FROM base_role WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC, f_full_name ASC \ - LIMIT $1::text::integer OFFSET $2::text::integer", - ¶ms, - ) - .await - { - Ok(rows) => rows, - Err(e) => return db_error(e, "角色列表查询"), - }; - - ok(page_list(page.current_page, page.page_size, total, rows)) -} - -// ---------------------------------------------------------------- 组织列表 - -/// `GET /api/permission/Organize/AsyncList/{id}` —— 官方 `OrganizeController.java:107-110`。 -/// -/// 🔴 **按 parentId 逐层取**(`id` = 父节点 id,根为 `0`)—— 官方前端就是靠这个接口 -/// 逐层展开机构树 ⇒ **不能**只有「全量列表」。 -/// -/// 🔴 响应是 `ActionResult>` ⇒ **`data` 是 `{pagination, list}`**。 -pub async fn organize_async_list( - State(state): State, - headers: HeaderMap, - Path(parent_id): Path, -) -> Json { - if let Err(resp) = guard(&state, &headers, EN_ORGANIZE).await { - return resp; - } - let parent = parent_id.trim(); - let parent = if parent.is_empty() { "0" } else { parent }.to_string(); - - let rows = match state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ - COALESCE(f_parent_id, '0') AS \"parentId\", f_category AS \"category\", \ - f_manager_id AS \"managerId\", COALESCE(f_sort_code, 0) AS \"sortCode\", \ - COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ - f_description AS \"description\", f_organize_id_tree AS \"organizeIdTree\", \ - f_org_name_tree AS \"orgNameTree\", f_duty_position AS \"dutyPosition\", \ - (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\" \ - FROM base_organize WHERE f_delete_mark = 0 \ - AND COALESCE(f_parent_id, '0') = $1::text \ - ORDER BY f_sort_code ASC, f_full_name ASC", - &[&parent], - ) - .await - { - Ok(rows) => rows, - Err(e) => return db_error(e, "组织列表查询"), - }; - - let total = rows.len() as i64; - ok(page_list(1, total.max(1), total, rows)) -} - -// ---------------------------------------------------------------- 菜单列表 - -/// `GET /api/system/Menu/ModuleBySystem` —— 官方 `ModuleController.java:121`。 -/// -/// 🔴 官方返回 `ActionResult>` ⇒ **`data` 是 `{list:[…]}`** -/// (**不是**裸数组;`ListVO` 全仓只有 `list` 一个字段)。 -/// -/// 🔴 **本仓单系统** ⇒ 忽略入参、返本仓全部菜单(**平铺**,`parentId` 表达层级)。 -pub async fn module_by_system( - State(state): State, - headers: HeaderMap, -) -> Json { - if let Err(resp) = guard(&state, &headers, EN_MENU).await { - return resp; - } - let sql = format!( - "SELECT {MENU_PROJECTION} FROM base_module WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC, f_full_name ASC" - ); - let rows = match state.db.query_json(&sql).await { - Ok(rows) => rows, - Err(e) => return db_error(e, "菜单列表查询"), - }; - let items: Vec = rows.iter().filter_map(parse_menu_row).collect(); - - // `hasChildren`:本行 id 出现在别人的 `parentId` 里。 - let parents: HashSet = items - .iter() - .filter(|m| m.parent_id != "0" && !m.parent_id.trim().is_empty()) - .map(|m| m.parent_id.clone()) - .collect(); - let list: Vec = items - .into_iter() - .map(|row| { - let has_children = parents.contains(&row.id); - menu_value(row, Vec::new(), has_children) - }) - .collect(); - - ok(list_vo(list)) -} - -// ---------------------------------------------------------------- 授权读取 - -/// `POST /api/permission/Authority/Data/{objectId}/Values` —— 官方 `AuthorizeController.java:99-100`。 -/// -/// **请求体**(官方 `DataValuesQuery.java:14-24`): -/// ```json -/// { "type":"module", "objectType":"role", "moduleIds":"" } -/// ``` -/// - `type` **不能为空**(官方直接返 `fail`)⇒ 本仓同样返 `fail(400)`; -/// - `moduleIds` 是**逗号分隔的字符串**(不是数组)—— 本仓读的是**已勾选**值, -/// 不靠 `moduleIds` 入参(那是「前端已勾选」的回传,官方用它做差集); -/// - `objectType` = `role` / `organize` / `position` / `user`。 -/// -/// **响应**(官方 `AuthorizeDataReturnVO.java:16-27`)= `{list, ids, all}`。 -/// -/// 🔴 **面 B v1 降级**(`JNPF_COMPAT_SURFACE.md` §3.6): -/// - `list` 恒 `[]` —— 本仓**不实现**官方那套权限树模型; -/// - `all` 返本仓**全部菜单 id**(官方的 `all` **不含**菜单 id)⇒ **已知错位 B1**; -/// - `ids` 语义**正确**(已勾选的菜单 id)。 -pub async fn authority_values( - State(state): State, - headers: HeaderMap, - Path(object_id): Path, - body: Bytes, -) -> Json { - if let Err(resp) = require_login_jnpf(&state, &headers).await { - return resp; - } - let obj = match parse_body(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - - let type_ = obj.get("type").and_then(Value::as_str).unwrap_or(""); - if type_.trim().is_empty() { - // 🔴 官方:`type` 为空 ⇒ 直接 `fail`(`AuthorizeController.java:112-114`)。 - return fail(code::FAIL, "type 不能为空"); - } - let object_type = obj - .get("objectType") - .and_then(Value::as_str) - .map(str::trim) - .filter(|s| !s.is_empty()) - .unwrap_or("role") - .to_string(); - - let ids = match granted_module_ids(&state.db, &object_type, &object_id).await { - Ok(ids) => ids, - Err(e) => return db_error(e, "授权读取"), - }; - let all = match all_module_ids(&state.db).await { - Ok(ids) => ids, - Err(e) => return db_error(e, "菜单全集查询"), - }; - - ok(json!({ - "list": [], - "ids": ids, - "all": all, - })) -} - -/// 已勾选的菜单 id(`base_authorize`,`f_item_type='module'`)。 -async fn granted_module_ids( - db: &Db, - object_type: &str, - object_id: &str, -) -> Result, pglite::Error> { - let object_type = object_type.to_string(); - let object_id = object_id.to_string(); - let rows = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = $1::text AND f_object_id = $2::text \ - AND f_item_type = 'module' AND f_delete_mark = 0", - &[&object_type, &object_id], - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r["itemId"].as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string) - .collect()) -} - -/// 本仓全部菜单 id(`all`)。 -async fn all_module_ids(db: &Db) -> Result, pglite::Error> { - let rows = db - .query_json( - "SELECT f_id AS \"id\" FROM base_module WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC, f_full_name ASC", - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r["id"].as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string) - .collect()) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn headers_with(vue_version: Option<&str>) -> HeaderMap { - let mut headers = HeaderMap::new(); - if let Some(v) = vue_version { - headers.insert( - VUE_VERSION, - axum::http::HeaderValue::from_str(v).expect("头值必须是合法 ASCII"), - ); - } - headers - } - - /// 🔴 **判别规则只有一条**:头 `Vue-Version: 3` ⇒ 面 B;否则面 A。 - #[test] - fn discriminator_is_vue_version_header() { - assert!(is_jnpf(&headers_with(Some("3")))); - assert!(!is_jnpf(&headers_with(None))); - // 🔴 本仓前端也发 `App-Code` / `Jnpf-Origin` ⇒ **不能**拿它们当判据。 - let mut headers = headers_with(None); - headers.insert("app-code", axum::http::HeaderValue::from_static("ssw-jnpf-lite-rust")); - headers.insert("jnpf-origin", axum::http::HeaderValue::from_static("pc")); - assert!(!is_jnpf(&headers), "App-Code / Jnpf-Origin 绝不能当判别头"); - } - - /// 头值带空格也应识别(HTTP 头值两侧空白无意义)。 - #[test] - fn discriminator_ignores_surrounding_whitespace() { - assert!(is_jnpf(&headers_with(Some(" 3 ")))); - } - - /// 头值不是 `3`(如 `2`)⇒ 不是面 B。 - #[test] - fn discriminator_rejects_other_values() { - assert!(!is_jnpf(&headers_with(Some("2")))); - assert!(!is_jnpf(&headers_with(Some("")))); - } - - /// 🔴 **官方 `PageListVO` 形状**:`{pagination:{currentPage,pageSize,total}, list:[…]}`。 - #[test] - fn page_list_vo_has_pagination_and_list() { - let v = page_list(2, 20, 42, vec![json!({"id": "u1"})]); - assert_eq!(v["pagination"]["currentPage"], 2); - assert_eq!(v["pagination"]["pageSize"], 20); - assert_eq!(v["pagination"]["total"], 42); - assert!(v["list"].is_array()); - assert_eq!(v["list"][0]["id"], "u1"); - } - - /// 🔴 **官方 `ListVO` 形状**:`{list:[…]}`(**只有** `list` 一个字段)。 - #[test] - fn list_vo_has_only_list() { - let v = list_vo(vec![json!({"id": "m1"})]); - assert!(v.get("list").is_some()); - assert!(v.get("pagination").is_none()); - assert_eq!(v.as_object().map(|o| o.len()), Some(1)); - } - - /// 分页参数:缺省 ⇒ 官方默认(`pageSize=20` / `currentPage=1`)。 - #[test] - fn paging_defaults_to_official_values() { - let raw = RawQuery(None); - let p = Paging::of(&raw); - assert_eq!(p.current_page, 1); - assert_eq!(p.page_size, 20); - assert_eq!(p.offset, 0); - } - - /// 分页参数:回显请求值;`pageSize=0` / 负数 ⇒ 夹到 1(不生成非法 SQL)。 - #[test] - fn paging_echoes_and_clamps() { - let raw = RawQuery(Some("currentPage=3&pageSize=5".to_string())); - let p = Paging::of(&raw); - assert_eq!(p.current_page, 3); - assert_eq!(p.page_size, 5); - assert_eq!(p.offset, 10); - - let raw = RawQuery(Some("pageSize=0¤tPage=-1".to_string())); - let p = Paging::of(&raw); - assert_eq!(p.current_page, 1); - assert_eq!(p.page_size, 1); - } - - /// 🔴 **菜单节点必须齐 15 个官方字段**(`AllMenuSelectVO.java:12-50`)。 - #[test] - fn menu_node_has_all_15_official_keys() { - let row = MenuRow { - id: "m1".to_string(), - full_name: "用户管理".to_string(), - en_code: Some("permission.user".to_string()), - parent_id: "0".to_string(), - icon: None, - url_address: Some("system/User".to_string()), - page_address: None, - link_target: None, - menu_type: 2, - property_json: None, - sort_code: 2, - system_id: None, - is_data: false, - }; - let v = menu_value(row, Vec::new(), false); - for key in [ - "id", - "fullName", - "enCode", - "parentId", - "icon", - "hasChildren", - "urlAddress", - "pageAddress", - "linkTarget", - "children", - "type", - "propertyJson", - "sortCode", - "systemId", - "isData", - ] { - assert!(v.get(key).is_some(), "面 B 菜单节点必须含键 {key}"); - } - // 🔴 `systemId` 为 NULL ⇒ 兜底成本仓系统 id(单系统)。 - assert_eq!(v["systemId"], SYSTEM_ID); - assert_eq!(v["isData"], false); - assert_eq!(v["children"].as_array().map(|a| a.len()), Some(0)); - } - - /// `propertyJson`:空 ⇒ `null`;合法 JSON ⇒ 解析;非法 ⇒ `null`。 - #[test] - fn property_json_is_parsed_or_null() { - assert_eq!(parse_property_json(None), Value::Null); - assert_eq!(parse_property_json(Some(" ")), Value::Null); - assert_eq!(parse_property_json(Some("{\"a\":1}"))["a"], 1); - assert_eq!(parse_property_json(Some("not json")), Value::Null); - } - - /// 🔴 **`permissionList` 的 `modelId` 是菜单 id**(官方语义:`find(o => o.modelId === menuId)`)。 - #[test] - fn permission_list_model_id_is_menu_id() { - let rows = vec![MenuRow { - id: "m_user".to_string(), - full_name: "用户管理".to_string(), - en_code: Some("permission.user".to_string()), - parent_id: "m_sys".to_string(), - icon: None, - url_address: None, - page_address: None, - link_target: None, - menu_type: 2, - property_json: None, - sort_code: 2, - system_id: None, - is_data: false, - }]; - let list = build_permission_list(&rows); - assert_eq!(list.len(), 1); - assert_eq!(list[0]["modelId"], "m_user"); - assert_eq!(list[0]["moduleName"], "用户管理"); - for key in ["button", "column", "resource", "form"] { - assert_eq!(list[0][key].as_array().map(|a| a.len()), Some(0)); - } - } -} diff --git a/src/backend/src/platform/menu.rs b/src/backend/src/platform/menu.rs deleted file mode 100644 index 6a27d26..0000000 --- a/src/backend/src/platform/menu.rs +++ /dev/null @@ -1,43 +0,0 @@ -//! menu —— **内置菜单 spec 的类型**(平台层)。 -//! -//! 🔴 **本文件只放「类型」,不放任何业务菜单**—— -//! 平台层自带的那 5 条系统菜单(`system` / `system/User` / `system/Role` / -//! `system/Organize` / `system/Module`)在 [`crate::platform::seed`] 里, -//! **业务菜单**(`demo-item` / `shop/Product` / `books/Book` …)由**业务层**各自声明 -//! (`modules/.rs` 的 `*_MENU`)⇒ **加一个业务模块不用改平台层**。 -//! -//! 🔴 **为什么菜单也要下沉**(与 [`crate::platform::entity::EntitySpec`] 同理): -//! 菜单的 `f_url_address`(前端 Route path)与 `f_en_code`(面 B 的点权限编码) -//! **都是业务知识** —— 写在平台层 ⇒ 加业务模块要改平台层 ⇒ 违反红线 12 -//! (「加一个业务模块只碰业务层」)。 -//! -//! 契约:`docs/contract.md` §8.4(内置菜单)。 - -/// 一条内置菜单的声明。 -/// -/// 🔴 **逐字对应 `base_module` 的列**(官方 DDL)—— `f_type` 是 **INTEGER** -/// (1 = 目录 / 2 = 页面),不是字符串。 -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct MenuSpec { - /// 字面量主键(`m_user` / `m_product` …)—— 种子 INSERT 用它。 - pub id: &'static str, - /// 全名(`用户管理` / `产品管理`)。 - pub full_name: &'static str, - /// 🔴 **面 B 的点权限编码**(`base_module.f_en_code`,官方 `@SaCheckPermission` 的判据)。 - /// - /// 面 A **不看**这一列(面 A 看 `f_url_address`)⇒ 两套判据并存、互不影响。 - pub en_code: &'static str, - /// 前端 Route path(去前导斜杠)—— 🔴 **面 A 的菜单守卫判据**。 - /// - /// 🔴 必须与①业务 spec 的 `module_key` ②前端 `` **一字不差** - /// (三者相等 ⇒ 菜单才显示、守卫才命中)。 - pub url_address: &'static str, - /// 父菜单 id(`0` = 根)。 - pub parent_id: &'static str, - /// 1 = 目录 / 2 = 页面 —— 🔴 官方 DDL 里 `f_type` 是 **INTEGER**。 - pub menu_type: i32, - /// 图标 —— `None` ⇒ 写 **NULL**(不是空串)。 - pub icon: Option<&'static str>, - /// 排序码。 - pub sort_code: i64, -} diff --git a/src/backend/src/platform/mod.rs b/src/backend/src/platform/mod.rs deleted file mode 100644 index d3f1a02..0000000 --- a/src/backend/src/platform/mod.rs +++ /dev/null @@ -1,31 +0,0 @@ -//! platform —— **平台层**(框架自带,用户加业务时**基本不动这里**)。 -//! -//! 分层约定(对齐 `ssw-jnpf-lite-react` 的 `common/` + `auth/` + `sys/`, -//! 以及官方 JNPF 的 `jnpf-common` + `jnpf-system`): -//! -//! | react 版 | rust 版 | 官方 JNPF Java | -//! |---|---|---| -//! | `common/`(信封 / cipher) | `envelope.rs` · `cipher.rs` | `jnpf-common` | -//! | `auth/`(登录 / token) | `auth.rs` · `session.rs` | `jnpf-common` | -//! | `sys/`(`base_*` 管理) | `sys.rs` · `permission.rs` · `seed.rs` | `jnpf-system` | -//! | `demo/` `shop/` `books/` | **`crate::modules`** | `jnpf-admin` | -//! -//! 🔴 **平台层不许出现业务知识**(表名、app_code、菜单 key 一律不进平台层): -//! 业务侧靠 [`entity::EntitySpec`] 把这些**声明**给引擎,引擎只读声明。 - -pub mod auth; -pub mod cipher; -pub mod config; -pub mod crud; -pub mod db; -pub mod entity; -pub mod envelope; -pub mod guard; -pub mod ids; -pub mod jnpf; -pub mod menu; -pub mod permission; -pub mod seed; -pub mod session; -pub mod state; -pub mod sys; diff --git a/src/backend/src/platform/permission.rs b/src/backend/src/platform/permission.rs deleted file mode 100644 index 19f7015..0000000 --- a/src/backend/src/platform/permission.rs +++ /dev/null @@ -1,440 +0,0 @@ -//! permission —— 四源权限合并 + 管理员短路 + 未映射放行 + 菜单树。 -//! -//! 契约:`docs/contract.md` §8.1(四源合并)/ §8.2(判定顺序)/ §8.3(菜单树)。 -//! -//! 逐字对齐 react 参考实现 `ssw-jnpf-lite-react/src/backend/src/sys/permission.service.ts` -//! (`resolveUserModuleIds` / `hasModule` / `buildMenuList` / `toTree`)。 -//! -//! 🔴 **判定顺序不可换**(§8.2): -//! 1. `is_admin == 1` ⇒ 放行(**不查任何 SQL**); -//! 2. 查 `base_module`(`f_url_address = key AND f_delete_mark = 0`) -//! —— **查不到 ⇒ 放行**(未映射放行,对齐 `SswPermissionGuard` 的 warn 路径); -//! 3. 查得到 ⇒ 该菜单 id 是否在四源合并集合里。 -//! -//! 🔴 **DB 报错 ≠「未映射放行」**(契约 §9 的签名没有 `Result` ⇒ 错误只能内部消解, -//! 且消解方向必须是**拒**): -//! - 「查不到」= SQL 执行成功、结果集为空 ⇒ **放行**; -//! - 「查询失败」= DB 报错 ⇒ **拒**(`has_module` 返回 `false`)。 -//! 两条路径必须**分开写** —— 写成 `if !found { return true }` 会把「DB 挂了」变成 -//! 「放行一切」⇒ **全站越权**(且静默)。 -//! -//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` —— 用户标识在 -//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` **才有** -//! `f_user_id`。写错列 ⇒ 授权永远不生效且**静默**。 -//! -//! 🔴 **只有 `base_authorize` 过滤 `f_delete_mark = 0`**(react 的 `addAuthorized` 只在 -//! 这一张表上加了 `deleteMark: 0`);`base_role_relation` / `base_user_relation` -//! **不过滤**软删 —— 照抄,不自作主张加过滤。 - -use std::collections::{HashMap, HashSet}; - -use serde::Serialize; - -use crate::platform::db::{pglite, pglite::ToSql, Db}; - -/// 菜单节点(契约 §8.3 的节点形状)。 -/// -/// 🔴 `url_address` / `icon` 为 `None` ⇒ 序列化成 `null`,**键仍在**(不省略)—— -/// 与 TypeORM 的 `nullable: true` 行为一致(内置的 `m_user` / `m_role` / `m_org` / -/// `m_menu` 的 `f_icon` 就是 NULL)。 -/// 🔴 `children` 恒存在(无子节点 ⇒ `[]`)。 -#[derive(Debug, Clone, Serialize)] -pub struct MenuNode { - /// 菜单 id(`base_module.f_id`)。 - pub id: String, - /// 菜单全名(`f_full_name`)。 - #[serde(rename = "fullName")] - pub full_name: String, - /// 前端 Route path(`f_url_address`)—— 可空。 - #[serde(rename = "urlAddress")] - pub url_address: Option, - /// 图标(`f_icon`)—— 可空。 - pub icon: Option, - /// 父菜单 id(`f_parent_id`)—— 空 ⇒ `'0'`。 - #[serde(rename = "parentId")] - pub parent_id: String, - /// 子菜单(按 `f_sort_code` 升序)。 - pub children: Vec, -} - -/// 一行菜单(内部用;`base_module` 的可见列)。 -struct MenuRow { - id: String, - full_name: String, - url_address: Option, - icon: Option, - parent_id: String, -} - -/// 菜单树的最大层数(防御 `f_parent_id` 被改成人为环时的无限递归)。 -/// -/// 🔴 **这是防御性上限,react 无此概念**(react 的 `toTree` 没有层数概念)—— -/// 契约 §8.3 对层数也无规定。截断只在「菜单嵌套 > 32 层」时生效, -/// 现实中不可达;不封顶则极深的链会让递归爆栈 ⇒ 整个进程死掉。 -const MAX_TREE_DEPTH: usize = 32; - -/// 四源合并(契约 §8.1)—— 用户可见的菜单 id 集合。 -/// -/// 四个来源: -/// 1. **直授**:`base_authorize`(`f_object_type='user'`); -/// 2. **角色**:`base_role_relation`(`f_object_type='user'`)⇒ `f_role_id` -/// ⇒ `base_authorize`(`f_object_type='role'`); -/// 3. **组织**:`base_user_relation`(`f_object_type='organize'`)⇒ `f_object_id` -/// ⇒ `base_authorize`(`f_object_type='organize'`); -/// 4. **岗位**:`base_user_relation`(`f_object_type='position'`)⇒ `f_object_id` -/// ⇒ `base_authorize`(`f_object_type='position'`)。 -/// -/// 🔴 **DB 报错 ⇒ 返回空集**(= 零授权,方向是「拒」),并 `eprintln!` 一行。 -/// 契约 §9 的签名没有 `Result` ⇒ 错误不能往外冒泡(否则会变成裸 HTTP 500)。 -pub async fn resolve_user_module_ids(db: &Db, user_id: &str) -> HashSet { - let mut ids: HashSet = HashSet::new(); - - // ---- 源 1:直授 ---- - if let Err(e) = add_authorized(db, &mut ids, "user", user_id).await { - eprintln!("[permission] 直授授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - - // ---- 源 2:角色 ---- - let role_ids = match query_user_role_ids(db, user_id).await { - Ok(ids) => ids, - Err(e) => { - eprintln!("[permission] 用户↔角色关系查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - }; - for role_id in role_ids { - if let Err(e) = add_authorized(db, &mut ids, "role", &role_id).await { - eprintln!("[permission] 角色授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - } - - // ---- 源 3:组织 ---- - let organize_ids = match query_user_relation_ids(db, user_id, "organize").await { - Ok(ids) => ids, - Err(e) => { - eprintln!("[permission] 用户↔组织关系查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - }; - for organize_id in organize_ids { - if let Err(e) = add_authorized(db, &mut ids, "organize", &organize_id).await { - eprintln!("[permission] 组织授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - } - - // ---- 源 4:岗位 ---- - let position_ids = match query_user_relation_ids(db, user_id, "position").await { - Ok(ids) => ids, - Err(e) => { - eprintln!("[permission] 用户↔岗位关系查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - }; - for position_id in position_ids { - if let Err(e) = add_authorized(db, &mut ids, "position", &position_id).await { - eprintln!("[permission] 岗位授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - } - - ids -} - -/// 菜单守卫(契约 §8.2)—— 当前用户能否访问 `module_key` 对应的菜单。 -/// -/// 🔴 判定顺序**不可换**: -/// 1. `is_admin == 1` ⇒ `true`(**不查任何 SQL**); -/// 2. 查 `base_module` —— **查不到 ⇒ `true`**(未映射放行); -/// 3. 查得到 ⇒ 菜单 id 是否在四源集合里。 -/// -/// 🔴 **DB 报错 ⇒ `false`(拒)** —— 绝不返回 `true`(那会是全站越权)。 -pub async fn has_module(db: &Db, user_id: &str, is_admin: i32, module_key: &str) -> bool { - // ---- 1) 管理员短路:在任何 SQL 之前 ---- - if is_admin == 1 { - return true; - } - - // ---- 2) 查菜单 ---- - let module_key = module_key.to_string(); - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_url_address = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&module_key], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - // 🔴 查询失败 ⇒ **拒**(不是「未映射」!) - eprintln!("[permission] 菜单查询失败(按拒绝处理): {e}"); - return false; - } - }; - // 「查不到」= 查询成功但没有这行 ⇒ 未映射放行(与上面的失败分支**必须分开**)。 - let Some(row) = rows.first() else { - return true; - }; - let Some(module_id) = row["id"].as_str() else { - // 主键不该是 NULL;万一如此 ⇒ 保守拒绝。 - eprintln!("[permission] 菜单行的 id 为空(按拒绝处理)"); - return false; - }; - - // ---- 3) 四源合并集合里有没有它 ---- - // (`resolve_user_module_ids` 出错 ⇒ 空集 ⇒ 这里自然是 `false`。) - resolve_user_module_ids(db, user_id).await.contains(module_id) -} - -/// **面 B 的点权限守卫** —— 当前用户能否访问 `f_en_code = en_code` 的菜单。 -/// -/// 🔴 这是**第二套判据**(面 A 用菜单路径 `f_url_address`;官方用 `f_en_code`), -/// 两者**并存**、互不影响(`JNPF_COMPAT_SURFACE.md` §3.2 / §7 S5)。 -/// 官方形态:`@SaCheckPermission("permission.user")` ⇒ 判「该用户是否持有 -/// `f_en_code='permission.user'` 的菜单授权」。 -/// -/// 🔴 **判定顺序与 [`has_module`] 逐字同构**(不可换): -/// 1. `is_admin == 1` ⇒ `true`(**不查任何 SQL**); -/// 2. 查 `base_module`(`f_en_code = $1 AND f_delete_mark = 0`) -/// —— **查不到 ⇒ `true`**(未映射放行,与面 A 同一条红线); -/// 3. 查得到 ⇒ 该菜单 id 是否在四源合并集合里。 -/// -/// 🔴 **DB 报错 ⇒ `false`(拒)** —— 绝不返回 `true`(那会是全站越权)。 -pub async fn has_en_code_permission( - db: &Db, - user_id: &str, - is_admin: i32, - en_code: &str, -) -> bool { - // ---- 1) 管理员短路:在任何 SQL 之前 ---- - if is_admin == 1 { - return true; - } - - // ---- 2) 查菜单(按 `f_en_code`)---- - let en_code = en_code.to_string(); - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_en_code = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&en_code], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - eprintln!("[permission] 菜单点权限查询失败(按拒绝处理): {e}"); - return false; - } - }; - // 「查不到」= 查询成功但没有这行 ⇒ 未映射放行(与上面的失败分支**必须分开**)。 - let Some(row) = rows.first() else { - return true; - }; - let Some(module_id) = row["id"].as_str() else { - eprintln!("[permission] 菜单行的 id 为空(按拒绝处理)"); - return false; - }; - - // ---- 3) 四源合并集合里有没有它 ---- - resolve_user_module_ids(db, user_id).await.contains(module_id) -} - -/// 当前用户可见的菜单树(契约 §8.3)。 -/// -/// - 取 `base_module` 中 `f_delete_mark = 0` 的行,按 `f_sort_code ASC`; -/// - 非管理员:过滤成「id 在四源集合里」的子集; -/// - 建树:`f_parent_id` 为空 / `'0'` / **父不在可见集合内** ⇒ 该节点是根; -/// 否则挂到父节点的 `children`。 -/// -/// 🔴 **DB 报错 ⇒ 返回空 `Vec`**(用户看不到任何入口,方向是「拒」)。 -pub async fn build_menu_list(db: &Db, user_id: &str, is_admin: i32) -> Vec { - let rows = match db - .query_json( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", \ - f_url_address AS \"urlAddress\", f_icon AS \"icon\", \ - f_parent_id AS \"parentId\" \ - FROM base_module WHERE f_delete_mark = 0 ORDER BY f_sort_code ASC", - ) - .await - { - Ok(rows) => rows, - Err(e) => { - eprintln!("[permission] 菜单列表查询失败(按空菜单处理): {e}"); - return Vec::new(); - } - }; - - let mut items: Vec = rows.iter().filter_map(parse_menu_row).collect(); - if is_admin != 1 { - let visible = resolve_user_module_ids(db, user_id).await; - items.retain(|m| visible.contains(&m.id)); - } - build_tree(items) -} - -/// 渲染单个菜单节点(**固定格式**,供菜单树断言逐字比对)。 -/// -/// 格式:`:` + 子节点的 `fullName` 用 `,` 连接 -/// (子节点若有子节点,其后代**不展开** —— 内置菜单最多两层,够用)。 -pub fn render(node: &MenuNode) -> String { - let kids: Vec = node.children.iter().map(|c| c.full_name.clone()).collect(); - format!("{}:{}", node.full_name, kids.join(",")) -} - -/// 渲染整棵菜单树(**固定格式**):根节点的渲染结果用 `|` 连接。 -pub fn render_tree(roots: &[MenuNode]) -> String { - roots.iter().map(render).collect::>().join("|") -} - -// ---- 内部实现 ---- - -/// 把某个对象(用户 / 角色 / 组织 / 岗位)的模块授权并进集合。 -/// -/// 🔴 **只有 `base_authorize` 过滤 `f_delete_mark = 0`**(react 的 `addAuthorized`)。 -async fn add_authorized( - db: &Db, - ids: &mut HashSet, - object_type: &str, - object_id: &str, -) -> Result<(), pglite::Error> { - let object_type = object_type.to_string(); - let object_id = object_id.to_string(); - let params: [&(dyn ToSql + Sync); 2] = [&object_type, &object_id]; - let rows = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = $1::text AND f_object_id = $2::text \ - AND f_item_type = 'module' AND f_delete_mark = 0", - ¶ms, - ) - .await?; - for row in rows { - if let Some(item_id) = row["itemId"].as_str() { - if !item_id.is_empty() { - ids.insert(item_id.to_string()); - } - } - } - Ok(()) -} - -/// 用户↔角色关系 ⇒ 角色 id 列表。 -/// -/// 🔴 `base_role_relation` **没有** `f_user_id` —— 用户标识在 `f_object_id` -/// (配 `f_object_type='user'`)。 -/// 🔴 **不过滤** `f_delete_mark`(照抄 react 的 `roleRelRepo.find`)。 -async fn query_user_role_ids(db: &Db, user_id: &str) -> Result, pglite::Error> { - let user_id = user_id.to_string(); - let params: [&(dyn ToSql + Sync); 1] = [&user_id]; - let rows = db - .query_json_params( - "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text", - ¶ms, - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r["roleId"].as_str().map(str::to_string)) - .filter(|id| !id.is_empty()) - .collect()) -} - -/// 用户↔组织 / 岗位关系 ⇒ 对象 id 列表。 -/// -/// 🔴 `base_user_relation` **才有** `f_user_id`。 -/// 🔴 **不过滤** `f_delete_mark`(照抄 react 的 `userRelRepo.find`)。 -async fn query_user_relation_ids( - db: &Db, - user_id: &str, - object_type: &str, -) -> Result, pglite::Error> { - let user_id = user_id.to_string(); - let object_type = object_type.to_string(); - let params: [&(dyn ToSql + Sync); 2] = [&user_id, &object_type]; - let rows = db - .query_json_params( - "SELECT f_object_id AS \"objectId\" FROM base_user_relation \ - WHERE f_user_id = $1::text AND f_object_type = $2::text", - ¶ms, - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r["objectId"].as_str().map(str::to_string)) - .filter(|id| !id.is_empty()) - .collect()) -} - -/// 一行 JSON ⇒ [`MenuRow`](`f_full_name` / `f_parent_id` 为 NULL ⇒ 取默认值)。 -fn parse_menu_row(row: &serde_json::Value) -> Option { - let id = row["id"].as_str()?.to_string(); - if id.is_empty() { - return None; - } - Some(MenuRow { - id, - full_name: row["fullName"].as_str().unwrap_or_default().to_string(), - url_address: row["urlAddress"].as_str().map(str::to_string), - icon: row["icon"].as_str().map(str::to_string), - // 🔴 react: `parentId: m.parentId || '0'` —— 空 ⇒ `'0'`。 - parent_id: match row["parentId"].as_str() { - Some(p) if !p.is_empty() => p.to_string(), - _ => "0".to_string(), - }, - }) -} - -/// 建树(逐字对齐 react 的 `toTree`)。 -/// -/// 🔴 根的判定:`parentId` 非空 **且** `!== '0'` **且** 父在可见集合内 ⇒ 挂到父节点; -/// 否则(含**父不在集合内**)⇒ **自己就是根**(不是被丢弃)。 -fn build_tree(items: Vec) -> Vec { - let visible: HashSet = items.iter().map(|m| m.id.clone()).collect(); - - let mut by_parent: HashMap> = HashMap::new(); - let mut roots: Vec = Vec::new(); - for item in items { - if item.parent_id != "0" && visible.contains(&item.parent_id) { - by_parent.entry(item.parent_id.clone()).or_default().push(item); - } else { - roots.push(item); - } - } - - roots - .into_iter() - .map(|row| build_node(row, &mut by_parent, 0)) - .collect() -} - -/// 递归建一棵子树。 -fn build_node( - row: MenuRow, - by_parent: &mut HashMap>, - depth: usize, -) -> MenuNode { - // 防御:`f_parent_id` 被改成人为环时不要无限递归(层数封顶 ⇒ 截断)。 - let children = if depth >= MAX_TREE_DEPTH { - Vec::new() - } else { - by_parent - .remove(&row.id) - .unwrap_or_default() - .into_iter() - .map(|child| build_node(child, by_parent, depth + 1)) - .collect() - }; - MenuNode { - id: row.id, - full_name: row.full_name, - url_address: row.url_address, - icon: row.icon, - parent_id: row.parent_id, - children, - } -} diff --git a/src/backend/src/platform/seed.rs b/src/backend/src/platform/seed.rs deleted file mode 100644 index ad4c3c6..0000000 --- a/src/backend/src/platform/seed.rs +++ /dev/null @@ -1,527 +0,0 @@ -//! seed —— 两段式种子(`ensure_base` 幂等 + `first_seed` 首启)。 -//! -//! 契约:`docs/contract.md` §8.4(内置菜单)/ §8.5(内置角色)/ §8.6(种子行为)。 -//! -//! 两段式: -//! - [`ensure_base`]:**每次启动都跑**,幂等 —— 只补缺项,**绝不覆盖已改值**; -//! - [`first_seed`]:**仅当 `base_user` 行数为 0 时**跑一次 —— 建 admin 用户 + 角色关联。 -//! -//! 🔴 **不复活软删行**:内置角色 / 内置菜单的存在性判定**不按 `f_delete_mark` 过滤** -//! (契约 §8.6 明确要求)⇒ 用户手动软删的行不会被种子「复活」。 -//! 🔴 **授权行同理**:`base_authorize` 的「已授权」判定也不按 `f_delete_mark` 过滤 -//! ⇒ 软删的授权行也算「已授权」⇒ 不补。 -//! -//! 🔴 **存在性判定必须与固定字面量 id 对齐**:内置角色按 -//! 「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判,内置菜单按 -//! 「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判 —— -//! INSERT 用的是**固定字面量 id**(`role_admin` / `m_user` …),若只按 -//! en_code / url 判,用户在 UI 改过内置项的这两个字段后就会「查不到 ⇒ 撞复合主键」 -//! ⇒ 种子失败 ⇒ 进程 exit 1 ⇒ 此后每次启动都失败(且服务起不来 ⇒ 用户也没法用 UI 改回去)。 -//! -//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` 列 —— 用户 id 存在 -//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` 才有 `f_user_id`。 -//! 写错列 ⇒ 授权永远不生效且**静默**。 -//! 🔴 7 张 `base_*` 表的主键是复合键 `(f_id, f_tenant_id)`,`f_tenant_id` 是 -//! `NOT NULL DEFAULT '0'` ⇒ **INSERT 必须显式写 `f_tenant_id='0'`**。 - -use crate::platform::cipher::md5_hex; -use crate::platform::db::{pglite, pglite::ToSql, Db}; -use crate::platform::ids::new_uuid; -use crate::platform::menu::MenuSpec; - -/// 内置 admin 账号名(同时用作种子的 `f_creator_user_id`)。 -const ADMIN_ACCOUNT: &str = "admin"; - -/// 内置 admin 角色的 `f_en_code`(内置角色清单里 `admin` 的编码)。 -const ADMIN_ROLE_EN_CODE: &str = "admin"; - -/// 内置 admin 角色的**字面量** id(`first_seed` 的角色关联引用它)。 -const ADMIN_ROLE_ID: &str = "role_admin"; - -/// 内置角色(契约 §8.5)—— 逐字值,**不得改动**。 -const BUILTIN_ROLES: [BuiltinRole; 2] = [ - BuiltinRole { - id: "role_admin", - full_name: "管理员", - en_code: "admin", - sort_code: 1, - }, - BuiltinRole { - id: "role_user", - full_name: "使用者", - en_code: "user", - sort_code: 2, - }, -]; - -/// 🔴 **平台层自带的内置菜单**(契约 §8.4)—— 逐字值,**不得改动**。 -/// -/// 🔴 **只含「系统管理」那 5 条**(`system` / `system/User` / `system/Role` / -/// `system/Organize` / `system/Module`)—— 它们是**平台层自己的**菜单 -/// (平台层提供 `base_*` 的管理端点 ⇒ 菜单是平台层的资产)。 -/// -/// 🔴 **业务菜单不在这里**(`demo-item` / `shop/Product` / `books/Book` …)—— -/// 那是**业务知识** ⇒ 由业务层各自声明(`modules/.rs` 的 `*_MENU`) -/// ⇒ **加一个业务模块不用改平台层**(红线 12)。 -/// -/// 🔴 **`en_code` 是面 B 的点权限判据**(官方 `@SaCheckPermission("permission.user")`) -/// —— 面 A 用 `f_url_address`、面 B 用 `f_en_code`,**两套并存**。 -const BUILTIN_MENUS: [MenuSpec; 5] = [ - MenuSpec { - id: "m_sys", - full_name: "系统管理", - en_code: "permission", - url_address: "system", - parent_id: "0", - menu_type: 1, - icon: Some("setting"), - sort_code: 1, - }, - MenuSpec { - id: "m_user", - full_name: "用户管理", - en_code: "permission.user", - url_address: "system/User", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 2, - }, - MenuSpec { - id: "m_role", - full_name: "角色管理", - en_code: "permission.role", - url_address: "system/Role", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 3, - }, - MenuSpec { - id: "m_org", - full_name: "机构管理", - en_code: "permission.organize", - url_address: "system/Organize", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 4, - }, - MenuSpec { - id: "m_menu", - full_name: "菜单管理", - en_code: "permission.menu", - url_address: "system/Module", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 5, - }, -]; - -/// 内置角色的一行(契约 §8.5)。 -struct BuiltinRole { - /// 字面量主键(`role_admin` / `role_user`)。 - id: &'static str, - /// 全名(`管理员` / `使用者`)。 - full_name: &'static str, - /// 编码(`admin` / `user`)—— **存在性判定的依据之一**(另一个是 `id`)。 - en_code: &'static str, - /// 排序码。 - sort_code: i64, -} - -/// 两段式种子的第一段:**补内置角色 / 内置菜单 / admin 授权**(幂等,每次启动都跑)。 -/// -/// 🔴 **`extra_menus` = 业务层声明的菜单**(`modules/.rs` 的 `*_MENU`)—— -/// 平台层**不认**任何业务菜单 ⇒ 业务菜单由**装配根** [`crate::bootstrap`] 传入 -/// ⇒ **加一个业务模块不用改平台层**(红线 12)。 -/// -/// 契约 §8.6。行为要点: -/// 1. 内置角色按「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判存在、 -/// 内置菜单按「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判存在 -/// —— 🔴 **都不按 `f_delete_mark` 过滤** ⇒ 软删行不被复活。 -/// 2. admin 授权按 `(f_object_type='role', f_object_id, f_item_type='module', f_item_id)` -/// 判存在 —— 🔴 同样**不按 `f_delete_mark` 过滤**。 -/// 3. **只补缺项,绝不覆盖已改值**(人工改名 / 调序 / 软删都会被保留)。 -pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite::Error> { - let now = now_str(); - ensure_builtin_roles(db, &now).await?; - let all_menus = all_builtin_menus(extra_menus); - ensure_builtin_menus(db, &now, &all_menus).await?; - ensure_admin_authorizations(db, &now, &all_menus).await?; - Ok(()) -} - -/// 平台层自带菜单 + 业务层传入的菜单 = **本次要种的全部内置菜单**。 -/// -/// 🔴 顺序 = 平台层 5 条在前、业务菜单在后 ⇒ 菜单 id / `f_sort_code` 的 -/// 分配由**各自声明它的那一层**负责(平台层管 1–5,业务层管 6+)。 -fn all_builtin_menus(extra: &[MenuSpec]) -> Vec { - let mut all: Vec = BUILTIN_MENUS.to_vec(); - all.extend_from_slice(extra); - all -} - -/// 两段式种子的第二段:**首次启动**建 admin 用户 + 角色关联。 -/// -/// 契约 §8.6:**仅当 `base_user` 行数为 0 时**才跑(否则直接返回,什么都不做)。 -/// -/// 🔴 `admin_password` = admin 的**明文**口令(内部只算 md5,**永不外泄**)。 -/// 缺省走 [`crate::platform::config::DEFAULT_SEED_ADMIN_PASSWORD`](`123456`,契约逐字要求), -/// 生产档可用 `SEED_ADMIN_PASSWORD` env 覆盖。 -pub async fn first_seed(db: &Db, admin_password: &str) -> Result<(), pglite::Error> { - let count = db.scalar_text("SELECT count(*) FROM base_user").await?; - // 🔴 `count(*)` 恒有一行;万一查不到(None)也**不**种(宁可少种也不要重复 admin)。 - if count.as_deref() != Some("0") { - return Ok(()); - } - - let now = now_str(); - seed_admin_user(db, &now, admin_password).await?; - seed_admin_role_relation(db).await?; - Ok(()) -} - -// ---- 内置角色 ---- - -/// 补内置角色(按 `f_en_code` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。 -async fn ensure_builtin_roles(db: &Db, now: &str) -> Result<(), pglite::Error> { - for role in BUILTIN_ROLES { - let id = role.id.to_string(); - let en_code = role.en_code.to_string(); - // 🔴 存在性判定 = 「`f_en_code` 命中 **或** `f_id` = 固定字面量」。 - // 只按 en_code 判会出事:用户把内置角色的 `f_en_code` 改掉后, - // 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒ - // 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。 - // 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」。 - let existing = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role \ - WHERE f_en_code = $1::text OR f_id = $2::text LIMIT 1", - &[&en_code, &id], - ) - .await?; - if !existing.is_empty() { - continue; - } - - let full_name = role.full_name.to_string(); - let role_type = "user".to_string(); - let sort_code = role.sort_code.to_string(); - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 10] = [ - &id, - &full_name, - &en_code, - &role_type, - &sort_code, - &enabled_mark, - &delete_mark, - &tenant_id, - &creator, - &now, - ]; - db.exec_params( - "INSERT INTO base_role \ - (f_id, f_full_name, f_en_code, f_type, f_sort_code, f_enabled_mark, \ - f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ - $6::text::integer, $7::text::integer, $8::text, $9::text, \ - $10::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -// ---- 内置菜单 ---- - -/// 补内置菜单(按 `f_url_address` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。 -/// -/// 🔴 `menus` = 平台层 5 条 + 业务层传入的 N 条(由 [`all_builtin_menus`] 拼好)。 -async fn ensure_builtin_menus( - db: &Db, - now: &str, - menus: &[MenuSpec], -) -> Result<(), pglite::Error> { - for menu in menus { - let id = menu.id.to_string(); - let url_address = menu.url_address.to_string(); - // 🔴 存在性判定 = 「`f_url_address` 命中 **或** `f_id` = 固定字面量」。 - // 只按 url 判会出事:用户把内置菜单的 `f_url_address` 改掉后, - // 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒ - // 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。 - // 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」(契约 §8.6 明确要求)。 - let existing = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_url_address = $1::text OR f_id = $2::text LIMIT 1", - &[&url_address, &id], - ) - .await?; - if !existing.is_empty() { - // 🔴 **存量库回填 `f_en_code`**:本仓早期版本的种子**不写** `f_en_code` - // ⇒ 存量库这些列全是 NULL ⇒ 面 B 的点权限判据全部落空 - // (`has_en_code_permission` 走「未映射 ⇒ 放行」分支 ⇒ 变成**全站放行**)。 - // 只在 **NULL 时**回填 ⇒ 人工改过的值不会被覆盖。 - let existing_id = existing - .first() - .and_then(|r| r["id"].as_str()) - .unwrap_or(id.as_str()) - .to_string(); - let en_code = menu.en_code.to_string(); - db.exec_params( - "UPDATE base_module SET f_en_code = $1::text \ - WHERE f_id = $2::text AND f_en_code IS NULL", - &[&en_code, &existing_id], - ) - .await?; - continue; - } - - let full_name = menu.full_name.to_string(); - let en_code = menu.en_code.to_string(); - let parent_id = menu.parent_id.to_string(); - let menu_type = menu.menu_type.to_string(); - // 🔴 图标为 `None` ⇒ 写 **NULL**(契约 §8.4 的 `—`,不是空串)。 - let icon = menu.icon.map(str::to_string); - let sort_code = menu.sort_code.to_string(); - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 13] = [ - &id, - &full_name, - &en_code, - &url_address, - &parent_id, - &menu_type, - &icon, - &sort_code, - &enabled_mark, - &delete_mark, - &tenant_id, - &creator, - &now, - ]; - db.exec_params( - "INSERT INTO base_module \ - (f_id, f_full_name, f_en_code, f_url_address, f_parent_id, f_type, f_icon, f_sort_code, \ - f_enabled_mark, f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, $7::text, \ - $8::text::bigint, $9::text::integer, $10::text::integer, $11::text, \ - $12::text, $13::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -// ---- admin 授权 ---- - -/// 补 admin 角色对内置菜单的授权(只补缺项)。 -/// -/// 契约 §8.6: -/// - admin 角色行取 `f_en_code='admin'` 的**真实**行(🔴 不按 `f_delete_mark` 过滤, -/// 可能是用户自建的行 ⇒ id 不等于 `role_admin`); -/// - 待授权的菜单 = `f_delete_mark=0` **且** `f_url_address` 命中内置清单的行; -/// - 「已授权」判定 = `base_authorize` 中 -/// `f_object_type='role' AND f_object_id= AND f_item_type='module'` -/// 的**全部行**(🔴 不按 `f_delete_mark` 过滤)。 -/// -/// 🔴 `menus` = 平台层 5 条 + 业务层传入的 N 条 ⇒ admin 角色对**全部内置菜单** -/// 都有授权(契约 §8.6:内置 8 条菜单 ⇒ admin 8 条授权)。 -async fn ensure_admin_authorizations( - db: &Db, - now: &str, - menus: &[MenuSpec], -) -> Result<(), pglite::Error> { - // ---- 1) 取 admin 角色的真实行 ---- - let en_code = ADMIN_ROLE_EN_CODE.to_string(); - // 🔴 用的是**查到的真实行**(可能是用户自建的行 ⇒ id 不等于 `role_admin`)。 - // `f_en_code` 没有 UNIQUE 约束(应用层保证唯一)⇒ 万一有多行,按 `f_id` 取 - // 最小的那条,保证结果**确定**(同库多次跑 ⇒ 同一个 id)。 - let admin_roles = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role WHERE f_en_code = $1::text \ - ORDER BY f_id LIMIT 1", - &[&en_code], - ) - .await?; - let Some(admin_role) = admin_roles.first() else { - // 没有 admin 角色 ⇒ 无从授权(`ensure_builtin_roles` 刚补过,除非被并发删了)。 - return Ok(()); - }; - let admin_role_id = admin_role["id"].as_str().unwrap_or_default().to_string(); - if admin_role_id.is_empty() { - return Ok(()); - } - - // ---- 2) 取内置菜单里「还活着」的行(f_delete_mark=0 且 url 命中清单)---- - let live_modules = db - .query_json( - "SELECT f_id AS \"id\", f_url_address AS \"urlAddress\" \ - FROM base_module WHERE f_delete_mark = 0", - ) - .await?; - let builtin_live: Vec = live_modules - .iter() - .filter(|row| { - row["urlAddress"] - .as_str() - .map(|url| menus.iter().any(|m| m.url_address == url)) - .unwrap_or(false) - }) - .filter_map(|row| row["id"].as_str().map(str::to_string)) - .collect(); - - // ---- 3) 取「已授权」的 f_item_id 集合 ---- - // - // 🔴 **不按 f_delete_mark 过滤** ⇒ 软删的授权行也算「已授权」⇒ 不补。 - let granted = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = 'role' AND f_object_id = $1::text \ - AND f_item_type = 'module'", - &[&admin_role_id], - ) - .await?; - let granted: Vec = granted - .iter() - .filter_map(|row| row["itemId"].as_str().map(str::to_string)) - .collect(); - - // ---- 4) 缺项 ⇒ 补一条授权 ---- - for menu_id in builtin_live { - if granted.iter().any(|g| g == &menu_id) { - continue; - } - let auth_id = new_uuid(); - let sort_code = "0".to_string(); - let delete_mark = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 7] = [ - &auth_id, - &admin_role_id, - &menu_id, - &sort_code, - &creator, - &now, - &delete_mark, - ]; - db.exec_params( - "INSERT INTO base_authorize \ - (f_id, f_object_type, f_object_id, f_item_type, f_item_id, f_sort_code, \ - f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, 'role', $2::text, 'module', $3::text, $4::text::bigint, \ - $5::text, $6::text::timestamp, $7::text::integer, '0')", - ¶ms, - ) - .await?; - } - Ok(()) -} - -// ---- 首启:admin 用户 + 角色关联 ---- - -/// 建 admin 用户(`f_password` = `md5_hex(admin_password)`)。 -/// -/// 🔴 `admin_password` 是**明文** ⇒ 立刻算 md5,**明文不进任何 SQL 参数、不进日志**。 -async fn seed_admin_user( - db: &Db, - now: &str, - admin_password: &str, -) -> Result<(), pglite::Error> { - let id = new_uuid(); - let account = ADMIN_ACCOUNT.to_string(); - let real_name = "管理员".to_string(); - let password = md5_hex(admin_password); - let is_administrator = "1".to_string(); - let organize_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let params: [&(dyn ToSql + Sync); 11] = [ - &id, - &account, - &real_name, - &password, - &is_administrator, - &organize_id, - &creator, - &now, - &enabled_mark, - &delete_mark, - &tenant_id, - ]; - db.exec_params( - "INSERT INTO base_user \ - (f_id, f_account, f_real_name, f_password, f_is_administrator, f_organize_id, \ - f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, $6::text, \ - $7::text, $8::text::timestamp, $9::text::integer, $10::text::integer, \ - $11::text)", - ¶ms, - ) - .await?; - Ok(()) -} - -/// 建 admin 的角色关联(`base_role_relation`)。 -/// -/// 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— 用户标识在 -/// `f_object_id`(配 `f_object_type='user'`);这里逐字用**账号名** `'admin'` -/// (react 源码里就是 `'admin'`,契约 §8.6 明确要求)。 -/// -/// 🔴 契约 §8.6 对这一行**逐字只列了 7 个字段**(`f_id` / `f_role_id` / `f_object_type` / -/// `f_object_id` / `f_sort_code` / `f_delete_mark` / `f_tenant_id`),**不含** -/// `f_creator_user_id` / `f_creator_time`(react 的 `roleRelRepo.save` 也不写这两列) -/// ⇒ 这里就**不写**(DDL 允许 NULL,不影响任何逻辑)。 -async fn seed_admin_role_relation(db: &Db) -> Result<(), pglite::Error> { - let id = new_uuid(); - let role_id = ADMIN_ROLE_ID.to_string(); - let object_type = "user".to_string(); - let object_id = ADMIN_ACCOUNT.to_string(); - let sort_code = "0".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let params: [&(dyn ToSql + Sync); 7] = [ - &id, - &role_id, - &object_type, - &object_id, - &sort_code, - &delete_mark, - &tenant_id, - ]; - db.exec_params( - "INSERT INTO base_role_relation \ - (f_id, f_role_id, f_object_type, f_object_id, f_sort_code, f_delete_mark, \ - f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ - $6::text::integer, $7::text)", - ¶ms, - ) - .await?; - Ok(()) -} - -/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 -fn now_str() -> String { - chrono::Utc::now() - .naive_utc() - .format("%Y-%m-%d %H:%M:%S") - .to_string() -} diff --git a/src/backend/src/platform/session.rs b/src/backend/src/platform/session.rs deleted file mode 100644 index 8c65cd1..0000000 --- a/src/backend/src/platform/session.rs +++ /dev/null @@ -1,181 +0,0 @@ -//! session —— 内存 token 会话表(进程内,进程重启即失效)。 -//! -//! 契约:登录成功后签发 token,后续请求带 `Authorization: bearer ` 解析出用户。 -//! -//! 🔴 **不用 Redis / Sa-Token**:本仓 v1 就是内存 token 表(与 JNPF 的 Sa-Token 内存模式同代)。 -//! -//! 🔴 **锁用 `std::sync::RwLock`**:访问全是同步的、无 await ⇒ 用 tokio 的锁会逼 `issue`/`resolve` -//! 变成 async,改变契约里定死的签名。 - -use std::collections::HashMap; -use std::sync::{Arc, RwLock}; - -use rand::Rng; - -use crate::platform::cipher::md5_hex; - -/// token 前缀(`"lite-"` + 32 个小写 hex ⇒ 总长 37)。 -const TOKEN_PREFIX: &str = "lite-"; - -/// `Authorization` 头里的 bearer 前缀(**含尾部空格**,共 7 字符)。 -const BEARER_PREFIX: &str = "bearer "; - -/// token 解析出来的用户信息。 -#[derive(Clone)] -pub struct TokenUser { - /// 用户主键(36 位 UUID v4)。 - pub user_id: String, - /// 登录账号。 - pub account: String, - /// 是否管理员(`base_user.f_is_administrator`,1 = 是)。 - pub is_admin: i32, -} - -/// 内存 token 表:`token -> TokenUser`。 -#[derive(Clone, Default)] -pub struct SessionStore { - /// 🔴 放在 `Arc` 里:多个 handler 共享同一张表。 - inner: Arc>>, -} - -impl SessionStore { - /// 建一张空表。 - pub fn new() -> Self { - Self { - inner: Arc::new(RwLock::new(HashMap::new())), - } - } - - /// 签发一个 token,返回值形状 = `"lite-" + 32 个小写 hex`(总长 37)。 - /// - /// token = `"lite-" + md5(account + 毫秒时间戳 + 随机数)`。 - pub fn issue(&self, account: &str, user_id: &str, is_admin: i32) -> String { - let millis = chrono::Utc::now().timestamp_millis(); - let rand: u64 = rand::thread_rng().gen(); - let digest = md5_hex(&format!("{}{}{}", account, millis, rand)); - - let token = format!("{}{}", TOKEN_PREFIX, digest); - let user = TokenUser { - user_id: user_id.to_string(), - account: account.to_string(), - is_admin, - }; - if let Ok(mut map) = self.inner.write() { - map.insert(token.clone(), user); - } - token - } - - /// 从 `Authorization` 头解析出用户。 - /// - /// - `None` / 空串 ⇒ `None`; - /// - 前 7 个字符大小写不敏感地命中 `"bearer "` ⇒ 截掉这 7 个字符查表; - /// - **不命中 ⇒ 整串当裸 token 查表**(有些客户端直接发裸 token); - /// - 查不到 ⇒ `None`。 - pub fn resolve(&self, auth_header: Option<&str>) -> Option { - let header = auth_header?.trim(); - if header.is_empty() { - return None; - } - - // 🔴 先看**前 7 个字节**:命中才截掉,否则整串当 token(大小写不敏感)。 - let bytes = header.as_bytes(); - let token = if bytes.len() >= BEARER_PREFIX.len() - && bytes[..BEARER_PREFIX.len()].eq_ignore_ascii_case(BEARER_PREFIX.as_bytes()) - { - &header[BEARER_PREFIX.len()..] - } else { - header - }; - if token.is_empty() { - return None; - } - - let map = self.inner.read().ok()?; - map.get(token).cloned() - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// token 形状:`"lite-"` 前缀 + 32 个小写 hex ⇒ 总长 37。 - #[test] - fn issued_token_shape() { - let store = SessionStore::new(); - let token = store.issue("admin", "uid-1", 1); - assert!(token.starts_with(TOKEN_PREFIX), "前缀必须是 lite-:{token}"); - let hex = &token[TOKEN_PREFIX.len()..]; - assert_eq!(hex.len(), 32, "必须是 32 个 hex 字符:{token}"); - assert_eq!(token.len(), 37, "总长必须是 37:{token}"); - assert!( - hex.chars().all(|c| c.is_ascii_digit() || ('a'..='f').contains(&c)), - "必须是小写 hex:{token}" - ); - } - - /// 签发后用 `bearer ` 能解析出正确的用户信息。 - #[test] - fn resolve_with_bearer_prefix() { - let store = SessionStore::new(); - let token = store.issue("zhangsan", "uid-abc", 0); - let got = store.resolve(Some(&format!("bearer {}", token))); - let user = got.expect("bearer 前缀必须能解析"); - assert_eq!(user.account, "zhangsan"); - assert_eq!(user.user_id, "uid-abc"); - assert_eq!(user.is_admin, 0); - } - - /// 前缀大小写不敏感(`BEARER` / `BeArEr` 都行)。 - #[test] - fn resolve_prefix_is_case_insensitive() { - let store = SessionStore::new(); - let token = store.issue("lisi", "uid-def", 1); - for prefix in ["BEARER ", "Bearer ", "beArEr "] { - let got = store.resolve(Some(&format!("{}{}", prefix, token))); - let user = got.unwrap_or_else(|| panic!("前缀 {} 必须能解析", prefix)); - assert_eq!(user.account, "lisi"); - assert_eq!(user.user_id, "uid-def"); - assert_eq!(user.is_admin, 1); - } - } - - /// 裸 token(不带前缀)也能解析。 - #[test] - fn resolve_bare_token() { - let store = SessionStore::new(); - let token = store.issue("wangwu", "uid-ghi", 0); - let got = store.resolve(Some(&token)); - assert_eq!(got.map(|u| u.account), Some("wangwu".to_string())); - } - - /// `None` / 空串 / 查不到的 token ⇒ `None`。 - #[test] - fn resolve_rejects_invalid() { - let store = SessionStore::new(); - assert!(store.resolve(None).is_none()); - assert!(store.resolve(Some("")).is_none()); - assert!(store.resolve(Some("bearer nope")).is_none()); - assert!(store.resolve(Some("nope")).is_none()); - } - - /// 两个不同签发的 token 互不干扰。 - #[test] - fn distinct_tokens_do_not_interfere() { - let store = SessionStore::new(); - let t1 = store.issue("u1", "id-1", 0); - let t2 = store.issue("u2", "id-2", 1); - assert_ne!(t1, t2, "两次签发不得相同"); - assert_eq!(store.resolve(Some(&t1)).map(|u| u.account), Some("u1".to_string())); - assert_eq!(store.resolve(Some(&t2)).map(|u| u.account), Some("u2".to_string())); - assert_eq!(store.resolve(Some(&t2)).map(|u| u.is_admin), Some(1)); - } - - /// `Default` 与 `new()` 等价(都能当空表用)。 - #[test] - fn default_is_empty_store() { - let store = SessionStore::default(); - assert!(store.resolve(Some("lite-whatever")).is_none()); - } -} diff --git a/src/backend/src/platform/state.rs b/src/backend/src/platform/state.rs deleted file mode 100644 index 815cb40..0000000 --- a/src/backend/src/platform/state.rs +++ /dev/null @@ -1,36 +0,0 @@ -//! state —— 全局应用状态(axum `Router` 的 `State`)。 -//! -//! 契约:规格 §9「AppState」。 -//! -//! 🔴 `config` 必须装在 `Arc` 里(`Config` 每次克隆都要复制 `PathBuf`), -//! 🔴 `db` 按契约写死 `Arc`(虽然 `Db` 本身是 `Clone`,但契约形状不改)。 -//! 🔴 `sessions` 用 `Arc` ⇒ 多 handler 共享同一张 token 表。 - -use std::sync::Arc; - -use crate::platform::config::Config; -use crate::platform::db::Db; -use crate::platform::session::SessionStore; - -/// 全局应用状态。 -#[derive(Clone)] -pub struct AppState { - /// 运行时配置(端口 / 数据目录 / 静态目录)。 - pub config: Arc, - /// pglite 封装。 - pub db: Arc, - /// 内存 token 会话表。 - pub sessions: Arc, -} - -#[cfg(test)] -mod tests { - use super::*; - - /// axum `State` 要求 `Clone + Send + Sync + 'static` —— 编译期钉住。 - #[test] - fn app_state_satisfies_axum_state_bounds() { - fn assert_state_bounds() {} - assert_state_bounds::(); - } -} diff --git a/src/backend/src/platform/sys.rs b/src/backend/src/platform/sys.rs deleted file mode 100644 index 820218e..0000000 --- a/src/backend/src/platform/sys.rs +++ /dev/null @@ -1,1295 +0,0 @@ -//! sys —— 5 组 `base_*` CRUD(User / Role / Organize / Module)+ 授权写入。 -//! -//! 契约:`docs/contract.md` §6.2 / §6.3(端点)+ §7.1–§7.5(语义)+ §7.7(唯一刻意偏离)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/sys/sys.service.ts` -//! 与 `.../sys/authorize.controller.ts`。 -//! -//! 🔴 **七条硬约定**: -//! 1. **业务失败恒 HTTP 200**(信封里的 `code=400`);DB 报错 ⇒ `系统异常,请联系管理员` -//! (真因只进服务端日志,**不外泄**)。 -//! 2. **不得 `SELECT *`**:每列显式 `AS ""`(**带双引号** —— PG 会把未加引号的 -//! 标识符折叠成小写 ⇒ `row_to_json` 出来的键会变成 `realname` ⇒ 前端读不到,且**静默**)。 -//! 3. **口令不得外泄**:`base_user` 的读回投影**根本不选 `f_password`** -//! (比「选了再删」更安全)⇒ List / Save 响应里**没有 `password` 键**。 -//! 4. **标识符白名单 + 参数化**:动态拼的表名/列名先过 `db::valid_table` / `db::valid_column`; -//! **所有用户数据**走绑定参数,绝不拼进 SQL 文本。 -//! 5. **只 SET body 里出现的键**(react / TypeORM `save` 的 `undefined` 语义,裁决 S16)。 -//! 🔴 这条保护 `base_module.f_url_address`(权限守卫的比对键)不被误清成 NULL。 -//! 6. **多步写用 data-modifying CTE 合成一条语句**(裁决 P59)⇒ 一条语句 = 一个隐式事务 = 原子。 -//! 7. **非测试代码零 `unwrap()` / `expect()` / `panic!()`**。 - -use std::collections::HashMap; - -use axum::body::Bytes; -use axum::extract::{Path, RawQuery, State}; -use axum::http::HeaderMap; -use axum::Json; -use serde_json::{json, Map, Value}; - -use crate::platform::auth::{require_login, require_login_any, require_module}; -use crate::platform::cipher::md5_hex; -use crate::platform::db::{self, pglite, pglite::ToSql, Db}; -use crate::platform::envelope::{fail, ok, ActionResult}; -use crate::platform::ids::new_uuid; -use crate::platform::state::AppState; - -// ---------------------------------------------------------------- 菜单守卫 key - -const USER_MODULE: &str = "system/User"; -const ROLE_MODULE: &str = "system/Role"; -const ORGANIZE_MODULE: &str = "system/Organize"; -const MODULE_MODULE: &str = "system/Module"; - -// ---------------------------------------------------------------- 投影列(契约 §5.3) - -/// `base_user` 的读回投影(12 列)—— 🔴 **不含 `f_password`**(R1.6:根本不选它)。 -const USER_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_account AS "account", -f_real_name AS "realName", f_secretkey AS "secretkey", -f_is_administrator AS "isAdministrator", f_role_id AS "roleId", -f_organize_id AS "organizeId", f_creator_user_id AS "creatorUserId", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_enabled_mark AS "enabledMark", f_delete_mark AS "deleteMark""#; - -/// `base_role` 的读回投影(11 列)。 -const ROLE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", -f_en_code AS "enCode", f_type AS "type", f_description AS "description", -f_enabled_mark AS "enabledMark", f_sort_code AS "sortCode", -f_creator_user_id AS "creatorUserId", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_delete_mark AS "deleteMark""#; - -/// `base_organize` 的读回投影(11 列)—— 🔴 **没有 `f_creator_user_id`**。 -const ORGANIZE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", -f_parent_id AS "parentId", f_category AS "category", f_en_code AS "enCode", -f_manager_id AS "managerId", f_sort_code AS "sortCode", f_enabled_mark AS "enabledMark", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_delete_mark AS "deleteMark""#; - -/// `base_module` 的读回投影(13 列)—— 🔴 **没有 `f_creator_user_id`**。 -const MODULE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", -f_url_address AS "urlAddress", f_parent_id AS "parentId", f_type AS "type", -f_category AS "category", f_en_code AS "enCode", f_icon AS "icon", -f_sort_code AS "sortCode", f_enabled_mark AS "enabledMark", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_delete_mark AS "deleteMark""#; - -// ---------------------------------------------------------------- 通用小工具 - -/// DB 报错 ⇒ 统一文案(契约 §R1.2 / §6.5)。 -fn db_error(e: pglite::Error, ctx: &str) -> Json { - eprintln!("[sys] {ctx}失败: {e}"); - fail(400, "系统异常,请联系管理员") -} - -/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 -fn now_str() -> String { - chrono::Utc::now() - .naive_utc() - .format("%Y-%m-%d %H:%M:%S") - .to_string() -} - -/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`(裁决 P61)。 -/// -/// 🔴 **不用 axum 的 `Json`**:它的解析失败会返回 **422 + 非信封 body** ⇒ 契约破。 -fn parse_body(body: &Bytes) -> Result> { - match serde_json::from_slice::(body) { - Ok(v) => Ok(v), - Err(_) => Err(fail(400, "请求参数格式错误")), - } -} - -/// 取 body 里的对象;**不是对象 ⇒ 空对象**(⇒ 走「参数缺失」的业务文案分支)。 -fn body_object(body: &Bytes) -> Result, Json> { - let v = parse_body(body)?; - Ok(match v { - Value::Object(m) => m, - _ => Map::new(), - }) -} - -/// 取 query 参数;**缺失 / 解析失败 ⇒ 空串**(视作「参数缺失」)。 -/// -/// 🔴 **不用 axum 的 `Query`**:它的解析失败会返回 **400 + 非信封 body** ⇒ 契约破。 -/// -/// 🔴 `pub(crate)` —— 面 B 的 `jnpf` 模块也要用它(官方分页参数 `currentPage` / `pageSize`)。 -pub(crate) fn query_param(raw: &RawQuery, key: &str) -> String { - let Some(q) = raw.0.as_deref() else { - return String::new(); - }; - let pairs: Vec<(String, String)> = serde_urlencoded::from_str(q).unwrap_or_default(); - pairs - .into_iter() - .find(|(k, _)| k == key) - .map(|(_, v)| v) - .unwrap_or_default() -} - -/// JS 真值判定(react 的 `dto.isAdministrator ? 1 : 0`)。 -fn truthy(v: Option<&Value>) -> bool { - match v { - None | Some(Value::Null) => false, - Some(Value::Bool(b)) => *b, - Some(Value::Number(n)) => n.as_f64().map(|f| f != 0.0).unwrap_or(false), - Some(Value::String(s)) => !s.is_empty(), - Some(Value::Array(a)) => !a.is_empty(), - Some(Value::Object(o)) => !o.is_empty(), - } -} - -/// `body.organizeId || '0'` / `body.parentId || '0'` 的 JS `||` 语义。 -fn or_zero(v: Option<&Value>) -> String { - match v { - Some(Value::String(s)) if !s.is_empty() => s.clone(), - _ => "0".to_string(), - } -} - -/// body 值 ⇒ 文本(`null` / 对象 / 数组 ⇒ `None` ⇒ 写 NULL)。 -fn value_to_text(v: Option<&Value>) -> Option { - match v { - Some(Value::String(s)) => Some(s.clone()), - Some(Value::Number(n)) => Some(n.to_string()), - Some(Value::Bool(b)) => Some(b.to_string()), - _ => None, - } -} - -/// body 里的 `id` ⇒ `Some(id 文本)`(有 id)/ `None`(无 id)。 -/// -/// 🔴 键存在且非 null、但**不是字符串**(如数字 `123`)⇒ **也算「有 id」**—— -/// react 的 `if (dto.id)` 对数字是 truthy ⇒ 走更新分支;按其 JSON 文本去查, -/// 查不到 ⇒ `400 '用户不存在'`(**不是**新建一行)。 -/// 空串 ⇒ 视作**无 id**(react 的 `if ('')` 是 falsy)。 -fn body_id(obj: &Map) -> Option { - match obj.get("id") { - None | Some(Value::Null) => None, - Some(Value::String(s)) if s.is_empty() => None, - Some(Value::String(s)) => Some(s.clone()), - Some(other) => Some(other.to_string()), - } -} - -/// body 里取一个整数(`null` / 不可解析 ⇒ `None`)。 -fn value_to_i64(v: Option<&Value>) -> Option { - match v { - Some(Value::Number(n)) => n.as_i64().or_else(|| n.as_f64().map(|f| f as i64)), - Some(Value::String(s)) => s.trim().parse::().ok(), - _ => None, - } -} - -/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 -/// -/// 🔴 `Option: ToSql` ⇒ `None` 会被编码成 SQL `NULL`(不是空串)。 -fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { - values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() -} - -/// 一条待写入的字段。 -struct Field { - /// 目标列(**内部常量**,拼进 SQL 前仍要过白名单)。 - column: &'static str, - /// 追加在 `::text` 之后的类型转换(`""` / `"::integer"` / `"::bigint"`)。 - cast: &'static str, - /// 值(`None` ⇒ NULL)。 - value: Option, -} - -/// 构造 `UPDATE SET ... WHERE f_id = $n::text`。 -/// -/// 🔴 表名 / 列名都过白名单(红线 R1.10);**值全部走绑定参数**。 -fn build_update( - table: &str, - id: &str, - fields: &[Field], -) -> Result<(String, Vec>), pglite::Error> { - let table = db::valid_table(table) - .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {table}")))?; - let mut values: Vec> = Vec::new(); - let mut assigns: Vec = Vec::new(); - for f in fields { - // 🔴 白名单不过 ⇒ **不拼进 SQL**(宁可少更新一列,也不让用户 body 里的键进 SQL 文本)。 - let Some(col) = db::valid_column(f.column) else { - continue; - }; - values.push(f.value.clone()); - assigns.push(format!("{} = ${}::text{}", col, values.len(), f.cast)); - } - if assigns.is_empty() { - return Err(pglite::Error::Protocol("没有可更新的字段".to_string())); - } - values.push(Some(id.to_string())); - let sql = format!( - "UPDATE {} SET {} WHERE f_id = ${}::text", - table, - assigns.join(", "), - values.len() - ); - Ok((sql, values)) -} - -/// 按 id 读回一行(`None` ⇒ 没有这行)。 -async fn fetch_by_id( - db: &Db, - table: &str, - columns: &str, - id: &str, -) -> Result, pglite::Error> { - let table = db::valid_table(table) - .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {table}")))?; - let sql = format!("SELECT {columns} FROM {table} WHERE f_id = $1::text LIMIT 1"); - let rows = db.query_json_params(&sql, &[&id]).await?; - Ok(rows.into_iter().next()) -} - -/// 用户的 `roleIds` / `roleNames`(一次性把关系表与角色表各查一遍,避免 N+1)。 -/// -/// 🔴 `base_role_relation` **不过滤 `f_delete_mark`**(照抄 react 的 `roleRelRepo.find`)。 -/// 🔴 `roleNames` 查不到就**跳过**(不是空串、不是 null)⇒ 长度可能小于 `roleIds`。 -async fn user_role_map( - db: &Db, -) -> Result, Vec)>, pglite::Error> { - let rels = db - .query_json( - "SELECT f_object_id AS \"objectId\", f_role_id AS \"roleId\" \ - FROM base_role_relation WHERE f_object_type = 'user'", - ) - .await?; - let roles = db - .query_json( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\" FROM base_role \ - WHERE f_delete_mark = 0", - ) - .await?; - let mut names: HashMap = HashMap::new(); - for r in &roles { - let (Some(id), Some(name)) = ( - r.get("id").and_then(Value::as_str), - r.get("fullName").and_then(Value::as_str), - ) else { - continue; - }; - names.insert(id.to_string(), name.to_string()); - } - - let mut map: HashMap, Vec)> = HashMap::new(); - for rel in &rels { - let (Some(object_id), Some(role_id)) = ( - rel.get("objectId").and_then(Value::as_str), - rel.get("roleId").and_then(Value::as_str), - ) else { - continue; - }; - let entry = map.entry(object_id.to_string()).or_default(); - entry.0.push(role_id.to_string()); - } - // `roleNames` 按 `roleIds` 的顺序取,查不到就跳过。 - for (role_ids, role_names) in map.values_mut() { - for rid in role_ids.iter() { - if let Some(name) = names.get(rid) { - role_names.push(name.clone()); - } - } - } - Ok(map) -} - -// ---------------------------------------------------------------- User - -/// `GET /api/ssw/sys/User/List`(契约 §6.2 / §7.1)。 -pub async fn user_list(State(state): State, headers: HeaderMap) -> Json { - if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {USER_COLUMNS} FROM base_user WHERE f_delete_mark = 0 \ - ORDER BY f_creator_time DESC" - ); - let rows = match state.db.query_json(&sql).await { - Ok(rows) => rows, - Err(e) => return db_error(e, "用户列表查询"), - }; - let role_map = match user_role_map(&state.db).await { - Ok(m) => m, - Err(e) => return db_error(e, "用户角色关系查询"), - }; - - let mut out: Vec = Vec::with_capacity(rows.len()); - for row in rows { - let Some(obj) = row.as_object() else { - continue; - }; - let id = obj.get("id").and_then(Value::as_str).unwrap_or_default(); - let (role_ids, role_names) = role_map.get(id).cloned().unwrap_or_default(); - let mut item = obj.clone(); - // 🔴 响应里**没有 `password` 键**(投影里根本没选 `f_password`)。 - item.insert("roleIds".to_string(), json!(role_ids)); - item.insert("roleNames".to_string(), json!(role_names)); - out.push(Value::Object(item)); - } - ok(Value::Array(out)) -} - -/// `POST /api/ssw/sys/User/Save`(契约 §7.1)。 -pub async fn user_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - - // ---- 1) 账号必填 ---- - let account = obj.get("account").and_then(Value::as_str).unwrap_or(""); - if account.is_empty() { - return fail(400, "账号不能为空"); - } - let account = account.to_string(); - - // ---- 2) 查重(新建 / 更新**都查**):只比 `f_delete_mark = 0` 的行 ---- - // 🔴 官方 DDL 对 `f_account` **无 UNIQUE** ⇒ 唯一性只在应用层。 - let dup = match state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_user \ - WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&account], - ) - .await - { - Ok(rows) => rows - .first() - .and_then(|r| r.get("id")) - .and_then(Value::as_str) - .map(str::to_string), - Err(e) => return db_error(e, "用户查重"), - }; - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - if dup.is_some() { - return fail(400, format!("账号已存在:{account}")); - } - let new_id = new_uuid(); - let real_name = value_to_text(obj.get("realName")); - // 🔴 body 没有 password ⇒ `md5('123456')`(react 的默认口令)。 - let password = match obj.get("password").and_then(Value::as_str) { - Some(p) if !p.is_empty() => md5_hex(p), - _ => md5_hex("123456"), - }; - let is_admin = if truthy(obj.get("isAdministrator")) { - "1" - } else { - "0" - }; - let organize_id = or_zero(obj.get("organizeId")); - let now = now_str(); - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(account.clone()), - real_name, - Some(password), - Some(is_admin.to_string()), - Some(organize_id), - Some("admin".to_string()), - Some(now), - Some("1".to_string()), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_user \ - (f_id, f_tenant_id, f_account, f_real_name, f_password, f_is_administrator, \ - f_organize_id, f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, \ - $7::text, $8::text, $9::text::timestamp, $10::text::integer, \ - $11::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建用户"); - } - if let Err(e) = write_user_roles(&state, &new_id, &obj).await { - return db_error(e, "用户角色关联写入"); - } - user_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(user_id) => { - // 🔴 按 `f_id` 查,**不按 `f_delete_mark` 过滤** ⇒ 软删过的行也算存在。 - let exists = match fetch_by_id(&state.db, "base_user", USER_COLUMNS, &user_id).await { - Ok(v) => v.is_some(), - Err(e) => return db_error(e, "用户查询"), - }; - if !exists { - return fail(400, "用户不存在"); - } - // 🔴 dup 存在**且**不是自己 ⇒ 账号已被占用。 - if let Some(dup_id) = &dup { - if dup_id != &user_id { - return fail(400, format!("账号已存在:{account}")); - } - } - - let mut fields: Vec = Vec::new(); - // `f_account` 必覆盖(body 里 account 必填)。 - fields.push(Field { - column: "f_account", - cast: "", - value: Some(account.clone()), - }); - // `f_real_name`:**body 有才覆盖**(裁决 S16)。 - if obj.contains_key("realName") { - fields.push(Field { - column: "f_real_name", - cast: "", - value: value_to_text(obj.get("realName")), - }); - } - // `f_is_administrator`:**总是**覆盖为 body 真值 ? 1 : 0。 - fields.push(Field { - column: "f_is_administrator", - cast: "::integer", - value: Some( - if truthy(obj.get("isAdministrator")) { - "1" - } else { - "0" - } - .to_string(), - ), - }); - // `f_organize_id`:**总是**覆盖为 `body.organizeId || '0'`。 - fields.push(Field { - column: "f_organize_id", - cast: "", - value: Some(or_zero(obj.get("organizeId"))), - }); - // `f_password`:**body.password 非空才**覆盖。 - if let Some(p) = obj.get("password").and_then(Value::as_str) { - if !p.is_empty() { - fields.push(Field { - column: "f_password", - cast: "", - value: Some(md5_hex(p)), - }); - } - } - // ⚠️ 更新**不**碰 `f_creator_time` / `f_enabled_mark` / `f_delete_mark`。 - let (sql, values) = match build_update("base_user", &user_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造用户更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新用户"); - } - if let Err(e) = write_user_roles(&state, &user_id, &obj).await { - return db_error(e, "用户角色关联写入"); - } - user_payload(&state, &user_id).await - } - } -} - -/// `DELETE /api/ssw/sys/User/Delete?id=`(契约 §7.1)。 -/// -/// 🔴 **不检查用户是否存在** ⇒ 不存在也返回成功(幂等)。 -pub async fn user_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 软删用户 + 硬删角色关联 ⇒ **一条语句**(data-modifying CTE)⇒ 原子(裁决 P59)。 - let sql = "WITH d AS (UPDATE base_user SET f_delete_mark = 1 WHERE f_id = $1::text) \ - DELETE FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除用户"); - } - ok(Value::Null) -} - -/// 写用户的角色关联:`roleIds` 是数组 ⇒ **先硬删旧行再插新行**(契约 §7.1 第 5 条)。 -/// -/// 🔴 `roleIds` **不是数组**(缺省 / 类型不对)⇒ **不动**已有关系(react 的 -/// `Array.isArray(dto.roleIds)` 判定)。 -/// -/// 🔴 **DB 错误必须往上抛**(不吞)—— 吞掉的话角色授权根本没生效,响应却还是 -/// `code=200 / 成功` ⇒ 调用方拿到的信封与库里的事实不符。 -async fn write_user_roles( - state: &AppState, - user_id: &str, - obj: &Map, -) -> Result<(), pglite::Error> { - let Some(Value::Array(items)) = obj.get("roleIds") else { - return Ok(()); - }; - let role_ids: Vec = items - .iter() - .filter_map(|v| v.as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string) - .collect(); - - // 🔴 原始数组非空、但过滤后一个合法 id 都没有 ⇒ 这是**非法输入**, - // 不是「清空角色」。⇒ **不动**已有关系行(不要硬删)。 - if !items.is_empty() && role_ids.is_empty() { - return Ok(()); - } - - let mut values: Vec> = vec![Some(user_id.to_string())]; - let sql = if role_ids.is_empty() { - // 空数组 ⇒ 只删不插。 - "DELETE FROM base_role_relation WHERE f_object_type = 'user' AND f_object_id = $1::text" - .to_string() - } else { - let mut rows: Vec = Vec::new(); - for rid in &role_ids { - values.push(Some(new_uuid())); - values.push(Some(rid.clone())); - rows.push(format!( - "(${}::text, ${}::text)", - values.len() - 1, - values.len() - )); - } - // 硬删旧行 + 插新行 ⇒ **一条语句**(data-modifying CTE)⇒ 原子(裁决 P59)。 - format!( - "WITH d AS (DELETE FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text) \ - INSERT INTO base_role_relation \ - (f_id, f_tenant_id, f_object_type, f_object_id, f_role_id, f_sort_code, f_delete_mark) \ - SELECT v.f_id, '0', 'user', $1::text, v.f_role_id, 0, 0 \ - FROM (VALUES {}) AS v(f_id, f_role_id)", - rows.join(", ") - ) - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return Err(e); - } - Ok(()) -} - -/// 用户 Save 的响应体 = 落库后该用户行(**去掉 password**)+ `roleIds` + `roleNames`。 -async fn user_payload(state: &AppState, user_id: &str) -> Json { - let row = match fetch_by_id(&state.db, "base_user", USER_COLUMNS, user_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "读回用户"), - }; - let Some(mut obj) = row.and_then(|r| r.as_object().cloned()) else { - return fail(400, "用户不存在"); - }; - let role_map = match user_role_map(&state.db).await { - Ok(m) => m, - Err(e) => return db_error(e, "用户角色关系查询"), - }; - let (role_ids, role_names) = role_map.get(user_id).cloned().unwrap_or_default(); - obj.insert("roleIds".to_string(), json!(role_ids)); - obj.insert("roleNames".to_string(), json!(role_names)); - ok(Value::Object(obj)) -} - -// ---------------------------------------------------------------- Role - -/// `GET /api/ssw/sys/Role/List`(契约 §7.2)。 -pub async fn role_list(State(state): State, headers: HeaderMap) -> Json { - if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {ROLE_COLUMNS} FROM base_role WHERE f_delete_mark = 0 ORDER BY f_sort_code ASC" - ); - match state.db.query_json(&sql).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "角色列表查询"), - } -} - -/// `POST /api/ssw/sys/Role/Save`(契约 §7.2)。 -pub async fn role_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); - if full_name.is_empty() { - return fail(400, "角色名称不能为空"); - } - let full_name = full_name.to_string(); - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - // 先查重 `f_en_code`(只比未软删的行)。 - let en_code = value_to_text(obj.get("enCode")); - if let Some(code) = &en_code { - let dup = match state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role \ - WHERE f_en_code = $1::text AND f_delete_mark = 0 LIMIT 1", - &[code], - ) - .await - { - Ok(rows) => rows.first().is_some(), - Err(e) => return db_error(e, "角色查重"), - }; - if dup { - return fail(400, format!("角色编码已存在:{code}")); - } - } - let new_id = new_uuid(); - // `f_type` = `body.type ?? 'user'`。 - let role_type = match obj.get("type") { - Some(Value::Null) | None => "user".to_string(), - Some(v) => value_to_text(Some(v)).unwrap_or_else(|| "user".to_string()), - }; - let description = value_to_text(obj.get("description")); - let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); - let now = now_str(); - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(full_name), - en_code, - Some(role_type), - description, - Some("1".to_string()), - Some(sort_code.to_string()), - Some("admin".to_string()), - Some(now), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_role \ - (f_id, f_tenant_id, f_full_name, f_en_code, f_type, f_description, \ - f_enabled_mark, f_sort_code, f_creator_user_id, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ - $7::text::integer, $8::text::bigint, $9::text, $10::text::timestamp, \ - $11::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建角色"); - } - role_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(role_id) => { - // 🔴 按 `f_id` 查,**不带 `f_delete_mark` 过滤**。 - let existing = match fetch_by_id(&state.db, "base_role", ROLE_COLUMNS, &role_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "角色查询"), - }; - let Some(existing) = existing else { - return fail(400, "角色不存在"); - }; - // ⚠️ 更新**不做** `f_en_code` 查重;**不碰** `f_sort_code` / `f_enabled_mark`。 - let mut fields: Vec = Vec::new(); - fields.push(Field { - column: "f_full_name", - cast: "", - value: Some(full_name), - }); - if obj.contains_key("enCode") { - fields.push(Field { - column: "f_en_code", - cast: "", - value: value_to_text(obj.get("enCode")), - }); - } - // `f_type` = `body.type ?? 原值`。 - fields.push(Field { - column: "f_type", - cast: "", - value: match obj.get("type") { - Some(Value::Null) | None => existing - .get("type") - .and_then(Value::as_str) - .map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }); - if obj.contains_key("description") { - fields.push(Field { - column: "f_description", - cast: "", - value: value_to_text(obj.get("description")), - }); - } - let (sql, values) = match build_update("base_role", &role_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造角色更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新角色"); - } - role_payload(&state, &role_id).await - } - } -} - -/// `DELETE /api/ssw/sys/Role/Delete?id=`(契约 §7.2)。 -pub async fn role_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 软删角色 + 软删该角色的授权 + 硬删该角色的关系 ⇒ **一条语句**(原子)。 - let sql = "WITH a AS (UPDATE base_role SET f_delete_mark = 1 WHERE f_id = $1::text), \ - b AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_object_type = 'role' AND f_object_id = $1::text), \ - c AS (DELETE FROM base_role_relation WHERE f_role_id = $1::text) \ - SELECT 1"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除角色"); - } - ok(Value::Null) -} - -/// `GET /api/ssw/sys/Role/Modules?roleId=`(契约 §7.2)—— **仅登录**。 -pub async fn role_modules( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_login(&state, &headers).await { - return resp; - } - let role_id = query_param(&raw, "roleId"); - match role_module_ids(&state.db, &role_id).await { - Ok(ids) => ok(Value::Array(ids.into_iter().map(Value::String).collect())), - Err(e) => db_error(e, "角色菜单查询"), - } -} - -/// 角色的菜单 id 列表(契约 §7.2 / §7.5 —— 两处同一份语义)。 -async fn role_module_ids(db: &Db, role_id: &str) -> Result, pglite::Error> { - let rows = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = 'role' AND f_item_type = 'module' \ - AND f_object_id = $1::text AND f_delete_mark = 0", - &[&role_id], - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r.get("itemId").and_then(Value::as_str)) - .map(str::to_string) - .collect()) -} - -/// 角色 Save 的响应体 = 落库后该角色行。 -async fn role_payload(state: &AppState, role_id: &str) -> Json { - match fetch_by_id(&state.db, "base_role", ROLE_COLUMNS, role_id).await { - Ok(Some(row)) => ok(row), - Ok(None) => fail(400, "角色不存在"), - Err(e) => db_error(e, "读回角色"), - } -} - -// ---------------------------------------------------------------- Organize - -/// `GET /api/ssw/sys/Organize/List`(契约 §7.3)。 -pub async fn organize_list( - State(state): State, - headers: HeaderMap, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {ORGANIZE_COLUMNS} FROM base_organize WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC" - ); - match state.db.query_json(&sql).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "机构列表查询"), - } -} - -/// `POST /api/ssw/sys/Organize/Save`(契约 §7.3)。 -pub async fn organize_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); - if full_name.is_empty() { - return fail(400, "机构名称不能为空"); - } - let full_name = full_name.to_string(); - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - let new_id = new_uuid(); - let parent_id = or_zero(obj.get("parentId")); - // `f_category` = `body.category ?? NULL`。 - let category = match obj.get("category") { - Some(Value::Null) | None => None, - Some(v) => value_to_text(Some(v)), - }; - let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); - let now = now_str(); - // ⚠️ **不写 `f_creator_user_id`**(react 的 `base_organize` entity 没有该列)。 - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(full_name), - Some(parent_id), - category, - Some(sort_code.to_string()), - Some("1".to_string()), - Some(now), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_organize \ - (f_id, f_tenant_id, f_full_name, f_parent_id, f_category, f_sort_code, \ - f_enabled_mark, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::bigint, \ - $7::text::integer, $8::text::timestamp, $9::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建机构"); - } - organize_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(org_id) => { - let existing = - match fetch_by_id(&state.db, "base_organize", ORGANIZE_COLUMNS, &org_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "机构查询"), - }; - let Some(existing) = existing else { - return fail(400, "机构不存在"); - }; - // ⚠️ 更新**不碰** `f_sort_code` / `f_enabled_mark`。 - let mut fields: Vec = Vec::new(); - fields.push(Field { - column: "f_full_name", - cast: "", - value: Some(full_name), - }); - fields.push(Field { - column: "f_parent_id", - cast: "", - value: Some(or_zero(obj.get("parentId"))), - }); - // `f_category` = `body.category ?? 原值`。 - fields.push(Field { - column: "f_category", - cast: "", - value: match obj.get("category") { - Some(Value::Null) | None => existing - .get("category") - .and_then(Value::as_str) - .map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }); - let (sql, values) = match build_update("base_organize", &org_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造机构更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新机构"); - } - organize_payload(&state, &org_id).await - } - } -} - -/// `DELETE /api/ssw/sys/Organize/Delete?id=`(契约 §7.3)。 -pub async fn organize_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 先查子机构:有 ⇒ 拒删。 - let children = match state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_organize \ - WHERE f_parent_id = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&id], - ) - .await - { - Ok(rows) => rows, - Err(e) => return db_error(e, "子机构查询"), - }; - if !children.is_empty() { - return fail(400, "该机构下还有子机构,先删除子机构"); - } - let sql = "UPDATE base_organize SET f_delete_mark = 1 WHERE f_id = $1::text"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除机构"); - } - ok(Value::Null) -} - -/// 机构 Save 的响应体 = 落库后该机构行。 -async fn organize_payload(state: &AppState, org_id: &str) -> Json { - match fetch_by_id(&state.db, "base_organize", ORGANIZE_COLUMNS, org_id).await { - Ok(Some(row)) => ok(row), - Ok(None) => fail(400, "机构不存在"), - Err(e) => db_error(e, "读回机构"), - } -} - -// ---------------------------------------------------------------- Module - -/// `GET /api/ssw/sys/Module/List`(契约 §7.4)。 -pub async fn module_list( - State(state): State, - headers: HeaderMap, -) -> Json { - if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {MODULE_COLUMNS} FROM base_module WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC" - ); - match state.db.query_json(&sql).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "菜单列表查询"), - } -} - -/// `POST /api/ssw/sys/Module/Save`(契约 §7.4)。 -pub async fn module_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); - if full_name.is_empty() { - return fail(400, "菜单名称不能为空"); - } - let full_name = full_name.to_string(); - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - let new_id = new_uuid(); - let url_address = value_to_text(obj.get("urlAddress")); - let parent_id = or_zero(obj.get("parentId")); - // 🔴 `f_type` 是 **INTEGER**(1=目录 / 2=页面),缺省 **2**。 - let module_type = value_to_i64(obj.get("type")).unwrap_or(2); - // `f_category` 是 **VARCHAR 分类**,缺省 NULL。 - let category = match obj.get("category") { - Some(Value::Null) | None => None, - Some(v) => value_to_text(Some(v)), - }; - let icon = value_to_text(obj.get("icon")); - let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); - let now = now_str(); - // ⚠️ **不写 `f_creator_user_id`**(react 的 `base_module` entity 没有该列)。 - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(full_name), - url_address, - Some(parent_id), - Some(module_type.to_string()), - category, - icon, - Some(sort_code.to_string()), - Some("1".to_string()), - Some(now), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_module \ - (f_id, f_tenant_id, f_full_name, f_url_address, f_parent_id, f_type, \ - f_category, f_icon, f_sort_code, f_enabled_mark, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, \ - $7::text, $8::text, $9::text::bigint, $10::text::integer, \ - $11::text::timestamp, $12::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建菜单"); - } - module_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(module_id) => { - let existing = - match fetch_by_id(&state.db, "base_module", MODULE_COLUMNS, &module_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "菜单查询"), - }; - let Some(existing) = existing else { - return fail(400, "菜单不存在"); - }; - let mut fields: Vec = Vec::new(); - fields.push(Field { - column: "f_full_name", - cast: "", - value: Some(full_name), - }); - // 🔴 `f_url_address` **body 没这个键 ⇒ 不动原值** —— - // 它是权限守卫的比对键,被清成 NULL 会造成「静默越权」(裁决 S16)。 - if obj.contains_key("urlAddress") { - fields.push(Field { - column: "f_url_address", - cast: "", - value: value_to_text(obj.get("urlAddress")), - }); - } - fields.push(Field { - column: "f_parent_id", - cast: "", - value: Some(or_zero(obj.get("parentId"))), - }); - // `f_type` = `body.type ?? 原值`。 - let orig_type = existing.get("type").and_then(Value::as_i64); - let new_type = match obj.get("type") { - Some(Value::Null) | None => orig_type, - Some(v) => value_to_i64(Some(v)).or(orig_type), - }; - fields.push(Field { - column: "f_type", - cast: "::integer", - value: new_type.map(|v| v.to_string()), - }); - // `f_category` = `body.category ?? 原值`。 - fields.push(Field { - column: "f_category", - cast: "", - value: match obj.get("category") { - Some(Value::Null) | None => existing - .get("category") - .and_then(Value::as_str) - .map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }); - // `f_icon`:**body 没这个键 ⇒ 不动原值**。 - if obj.contains_key("icon") { - fields.push(Field { - column: "f_icon", - cast: "", - value: value_to_text(obj.get("icon")), - }); - } - // `f_sort_code` = `body.sortCode ?? 0`(⚠️ 缺省 ⇒ **0**,不是原值)。 - fields.push(Field { - column: "f_sort_code", - cast: "::bigint", - value: Some(value_to_i64(obj.get("sortCode")).unwrap_or(0).to_string()), - }); - let (sql, values) = match build_update("base_module", &module_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造菜单更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新菜单"); - } - module_payload(&state, &module_id).await - } - } -} - -/// `DELETE /api/ssw/sys/Module/Delete?id=`(契约 §7.4)。 -pub async fn module_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 软删菜单 + 软删该菜单的授权 ⇒ **一条语句**(原子)。 - let sql = "WITH a AS (UPDATE base_module SET f_delete_mark = 1 WHERE f_id = $1::text), \ - b AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_item_type = 'module' AND f_item_id = $1::text) \ - SELECT 1"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除菜单"); - } - ok(Value::Null) -} - -/// 菜单 Save 的响应体 = 落库后该菜单行。 -async fn module_payload(state: &AppState, module_id: &str) -> Json { - match fetch_by_id(&state.db, "base_module", MODULE_COLUMNS, module_id).await { - Ok(Some(row)) => ok(row), - Ok(None) => fail(400, "菜单不存在"), - Err(e) => db_error(e, "读回菜单"), - } -} - -// ---------------------------------------------------------------- 授权 - -/// `PUT /api/permission/Authority/Data/{objectId}`(契约 §7.5)—— **仅登录**。 -/// -/// 🔴 **body 里的 `objectType` 被完全忽略**(react 只读 `body.module`) -/// ⇒ 落库一律 `f_object_type='role'`、`f_item_type='module'`、`f_object_id=`。 -/// **不要**因为 body 传了 `'Role'` 就拒绝(裁决:react 不校验,本仓也不校验)。 -/// -/// 🔴 **面 B 分流**:未登录时面 A 返 `600`、面 B 返 `602` -/// (官方前端只对 `601`/`602` 清 token ⇒ 返 `600` 会卡住不跳登录)。 -pub async fn authority_data( - State(state): State, - headers: HeaderMap, - Path(object_id): Path, - body: Bytes, -) -> Json { - if let Err(resp) = require_login_any(&state, &headers).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let module_ids = normalize_module(obj.get("module")); - if let Err(e) = write_role_modules(&state.db, &object_id, &module_ids).await { - return db_error(e, "写授权"); - } - ok(Value::Null) -} - -/// `GET /api/permission/Authority/RoleModules?roleId=`(契约 §7.5)—— **仅登录**。 -pub async fn authority_role_modules( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_login(&state, &headers).await { - return resp; - } - let role_id = query_param(&raw, "roleId"); - match role_module_ids(&state.db, &role_id).await { - Ok(ids) => ok(Value::Array(ids.into_iter().map(Value::String).collect())), - Err(e) => db_error(e, "角色菜单查询"), - } -} - -/// 归一化 `module`(react 的 `normalizeModule`)。 -/// -/// - **不是数组**(缺省 / 类型不对)⇒ `[]`; -/// - `module[0]` 是数组 ⇒ **展平一层**(兼容官方前端的 `[checked, halfChecked]` 二维形态); -/// - 只保留**非空字符串**。 -fn normalize_module(raw: Option<&Value>) -> Vec { - let Some(Value::Array(items)) = raw else { - return Vec::new(); - }; - let flatten = matches!(items.first(), Some(Value::Array(_))); - let mut out: Vec = Vec::new(); - for item in items { - if flatten { - match item { - Value::Array(inner) => { - for x in inner { - if let Some(s) = x.as_str() { - if !s.is_empty() { - out.push(s.to_string()); - } - } - } - } - other => { - if let Some(s) = other.as_str() { - if !s.is_empty() { - out.push(s.to_string()); - } - } - } - } - } else if let Some(s) = item.as_str() { - if !s.is_empty() { - out.push(s.to_string()); - } - } - } - out -} - -/// 写「角色 → 菜单」授权:先软删旧行,再插新行。 -/// -/// 🔴 **一条语句**(data-modifying CTE)⇒ 软删 + 插入原子(裁决 P59)。 -/// ⚠️ 空数组 ⇒ **只软删不插**。 -async fn write_role_modules( - db: &Db, - object_id: &str, - module_ids: &[String], -) -> Result<(), pglite::Error> { - if module_ids.is_empty() { - let sql = "WITH d AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_object_type = 'role' AND f_item_type = 'module' \ - AND f_object_id = $1::text) \ - SELECT 1"; - db.exec_params(sql, &[&object_id]).await?; - return Ok(()); - } - let mut values: Vec> = vec![Some(object_id.to_string())]; - let mut rows: Vec = Vec::new(); - for module_id in module_ids { - values.push(Some(new_uuid())); - values.push(Some(module_id.clone())); - rows.push(format!( - "(${}::text, ${}::text)", - values.len() - 1, - values.len() - )); - } - let sql = format!( - "WITH d AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_object_type = 'role' AND f_item_type = 'module' \ - AND f_object_id = $1::text) \ - INSERT INTO base_authorize \ - (f_id, f_tenant_id, f_object_type, f_object_id, f_item_id, f_item_type, \ - f_sort_code, f_delete_mark) \ - SELECT v.f_id, '0', 'role', $1::text, v.f_item_id, 'module', 0, 0 \ - FROM (VALUES {}) AS v(f_id, f_item_id)", - rows.join(", ") - ); - db.exec_params(&sql, ¶ms_of(&values)).await?; - Ok(()) -} diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs deleted file mode 100644 index 24b2aec..0000000 --- a/src/backend/src/routes.rs +++ /dev/null @@ -1,759 +0,0 @@ -//! routes —— 路由装配 + 三层兜底(404 / 405 / 413 改写 / catch-all)。 -//! -//! 契约:`docs/contract.md` §9(`routes.rs` 接口)、§6.5(兜底三条)、§R1.2(业务失败恒 HTTP 200)。 -//! -//! 🔴 **三层兜底的挂法**(控制器裁决 S25)—— **唯一真源**是 [`build_app`]: -//! ```text -//! build_app(state) // ← 生产(main.rs)与单测都调它 -//! build_router(state.clone()) -//! .fallback(not_found_handler) // 404 兜底 -//! .layer(m_status_rewrite()) // 405 / 413 改写中间件 -//! .layer(catch_all()) // panic 捕获中间件 -//! .with_state(state) // ← 链尾(唯一一次把类型落成 Router<()>) -//! ``` -//! `Router::layer` 是**后进先出** ⇒ 最后挂的最外层 ⇒ 请求**先**撞 `catch_all`, -//! **再**撞 `m_status_rewrite`,**最后**才进 handler / 404 兜底。 -//! -//! 🔴 `.fallback(...)` 必须写在两个 `.layer(...)` **之前** —— axum 官方文档原话: -//! 「the middleware is only applied to existing routes. So you have to first add your -//! routes (and / or fallback) and then call `layer` afterwards.」 -//! 否则 404 兜底不在中间件的保护范围内。 -//! -//! 🔴 **axum 0.8.9 用 matchit 0.8.4** —— 不支持 `{a,b}` 这种「一段里多个参数」的写法 -//! (会把 `List,Save,Delete` 当成**一个**参数名 ⇒ 路由能注册上但**永远匹配不到**, -//! 且**编译不报错**)⇒ 本文件**逐条**注册 27 条具体路径(见 S15 / S21)。 - -use std::any::Any; -use std::future::Future; -use std::panic::{catch_unwind, AssertUnwindSafe}; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use axum::body::Body; -use axum::extract::{Request, State}; -use axum::http::{header, HeaderMap, HeaderValue, StatusCode}; -use axum::middleware::Next; -use axum::response::{IntoResponse, Response}; -use axum::routing::{delete, get, post, put}; -use axum::{Json, Router}; -use serde_json::{json, Value}; - -use crate::modules; -use crate::platform::auth; -use crate::platform::envelope::{self, ActionResult}; -use crate::platform::jnpf; -use crate::platform::state::AppState; -use crate::platform::sys; - -/// 🔴 **仅测试构建**存在的 handler —— 故意 panic,用来钉住 catch-all 中间件 -/// (契约 §6.5:panic ⇒ HTTP 200 + `code=400`)。 -#[cfg(test)] -async fn panic_handler() -> Json { - panic!("测试用 panic(由 catch-all 中间件接住)") -} - -/// 装配全部路由(27 条,见 S15 的路由表)。 -/// -/// 🔴 **不在这里终结状态** —— 契约 §9 的括注与 §10 第 6 步都要求 -/// `with_state` 由调用方在**链尾**调用(axum 0.8 的 `Router` 的 `S` -/// 是「还缺什么状态」,`with_state` 必须是**链条最后一步**)。 -/// ⇒ **完整的装配链只有一份**,在 [`build_app`](生产与单测都调它)。 -/// -/// 这里末尾的 `.with_state(state)` 是**类型层面**的 no-op(`S2` 显式落在 `AppState` -/// ⇒ 返回类型仍是 `Router`):它只是让契约 §9 的 `state` 参数**有去处** -/// (否则 `unused_variables` warning ⇒ 验收门① 破),**并不**把状态喂给 handler。 -/// 🔴 **真正把状态喂给 handler 的是链尾那次 `with_state`**(在 [`build_app`] 里)。 -/// 🔴 两次拿到的是**同一个 `AppState` 的两个 clone** —— 而 `AppState` 的三个字段 -/// (`config` / `db` / `sessions`)**全是 `Arc`** ⇒ 两份 clone **共享同一份底层状态** -/// ⇒ 行为完全等价,**不是**两个独立状态。 -pub fn build_router(state: AppState) -> axum::Router { - let router = Router::new() - // ---- 探活(§6.5 末条,非契约)---- - .route("/api/health", get(health)) - // ---- 认证(§6.1)---- - .route("/api/oauth/Login", post(auth::login_handler)) - // 🔴 `auth::current_user` 收的是 `&AppState`(不是 `State`) - // ⇒ 不是合法的 extractor 组合 ⇒ **用闭包包一层**(S20)。 - .route( - "/api/oauth/CurrentUser", - get(|State(state): State, headers: HeaderMap| async move { - auth::current_user(&state, headers).await - }), - ) - // ---- 用户(§6.2 / §7.1)---- - .route("/api/ssw/sys/User/List", get(sys::user_list)) - .route("/api/ssw/sys/User/Save", post(sys::user_save)) - .route("/api/ssw/sys/User/Delete", delete(sys::user_delete)) - // ---- 角色(§6.2 / §7.2)---- - .route("/api/ssw/sys/Role/List", get(sys::role_list)) - .route("/api/ssw/sys/Role/Save", post(sys::role_save)) - .route("/api/ssw/sys/Role/Delete", delete(sys::role_delete)) - .route("/api/ssw/sys/Role/Modules", get(sys::role_modules)) - // ---- 机构(§6.2 / §7.3)---- - .route("/api/ssw/sys/Organize/List", get(sys::organize_list)) - .route("/api/ssw/sys/Organize/Save", post(sys::organize_save)) - .route("/api/ssw/sys/Organize/Delete", delete(sys::organize_delete)) - // ---- 菜单(§6.2 / §7.4)---- - .route("/api/ssw/sys/Module/List", get(sys::module_list)) - .route("/api/ssw/sys/Module/Save", post(sys::module_save)) - .route("/api/ssw/sys/Module/Delete", delete(sys::module_delete)) - // ---- 授权(§6.3 / §7.5)---- - // 🔴 全仓唯一的路径参数(axum 0.8 的花括号语法)。 - .route( - "/api/permission/Authority/Data/{objectId}", - put(sys::authority_data), - ) - .route( - "/api/permission/Authority/RoleModules", - get(sys::authority_role_modules), - ) - // ---- 业务模块(§6.4 / §7.6):demo / shop / books ---- - // 🔴 **业务路由不在本文件注册** —— 每个业务模块自带 `router()`(`modules/.rs`), - // 这里只 merge 一次 ⇒ 加业务模块**不动本文件**(对齐 react 版的 module 注册)。 - // ---- 面 B:官方 JNPF 契约面(`JNPF_COMPAT_SURFACE.md` §3)---- - // 🔴 **面 A 的 27 条路由一个都没动** —— 面 B 全部是**新增**的官方形状路径。 - // 唯一共用的是 `CurrentUser` / `Authority/Data`,它们按**判别头**分流 - // (`Vue-Version: 3` ⇒ 面 B)。 - .route("/api/permission/Users", get(jnpf::users_list)) - .route("/api/permission/Role", get(jnpf::roles_list)) - .route( - "/api/permission/Organize/AsyncList/{id}", - get(jnpf::organize_async_list), - ) - .route("/api/system/Menu/ModuleBySystem", get(jnpf::module_by_system)) - // 🔴 官方是 `POST /api/permission/Authority/Data/{objectId}/Values` - // —— 与面 A 的 `PUT .../Data/{objectId}` **同前缀不同方法不同路径** - // ⇒ matchit 0.8.4 允许「静态段跟在参数节点后」⇒ 两条可共存。 - .route( - "/api/permission/Authority/Data/{objectId}/Values", - post(jnpf::authority_values), - ) - // ---- 业务模块的路由(demo / shop / books)由业务层自带 ⇒ 这里只 merge ---- - .merge(modules::router()); - - // 🔴 **仅测试构建**存在的「故意 panic」端点 —— 用来钉住 catch-all 中间件 - // (契约 §6.5:panic ⇒ HTTP 200 + `code=400`)。 - // release 构建**不含**这条路由 ⇒ 生产环境没有这个面。 - #[cfg(test)] - let router = router.route("/api/__test__/panic", get(panic_handler)); - - router.with_state(state) -} - -/// 完整装配(**唯一权威的装配链**)—— 生产(`main.rs`)与单测**都调它**。 -/// -/// 🔴 顺序即 S25 的要害:`.fallback()` 必须在两个 `.layer()` **之前** -/// (axum:`layer` 只作用于**已注册**的路由)⇒ 否则 404 兜底不在中间件保护范围内。 -/// `.layer()` 是 per-route 的 ⇒ **最后挂的最外层** ⇒ 请求先撞 catch-all。 -/// 🔴 `with_state` 是**链尾**(唯一一次把类型落成 `Router<()>`)。 -/// -/// 🔴 **这条链在仓库里只有这一份** —— 生产与测试共用 ⇒ 改顺序时两边一起变, -/// 测试永远钉得住(不要在 `main.rs` 或测试里再抄一遍)。 -pub fn build_app(state: AppState) -> axum::Router { - build_router(state.clone()) - .fallback(not_found_handler) - .layer(m_status_rewrite()) - .layer(catch_all()) - .with_state(state) -} - -/// `GET /api/health` —— 探活(契约 §6.5 末条,**非契约**)。 -/// -/// 🔴 **永远要有响应**:查不到表 / DB 报错 ⇒ 仍然 HTTP 200 + `{"ok": false, "tables": 0, …}` -/// (它是给运维看的,不许 500)。 -async fn health(State(state): State) -> Json { - let version = env!("CARGO_PKG_VERSION"); - let text = state - .db - .scalar_text( - "SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'", - ) - .await - .ok() - .flatten(); - let tables = text.and_then(|t| t.trim().parse::().ok()); - match tables { - Some(n) => Json(json!({ "ok": true, "tables": n, "version": version })), - None => Json(json!({ "ok": false, "tables": 0, "version": version })), - } -} - -// ---------------------------------------------------------------- 404 兜底 - -/// 404 兜底 —— 未注册的路径。 -/// -/// 🔴 **必须显式配 `StatusCode::NOT_FOUND`** —— `envelope::fail()` 恒返回 HTTP 200 -/// (契约 §R1.1)⇒ 不显式配就变成「HTTP 200 + code=404」⇒ **契约破**。 -pub async fn not_found_handler() -> (StatusCode, Json) { - (StatusCode::NOT_FOUND, Json(envelope::fail(404, "接口不存在").0)) -} - -// ---------------------------------------------------------------- 405 / 413 改写中间件 - -/// 中间件 future 的统一类型(boxed ⇒ 可命名 ⇒ 工厂函数的返回类型能写死)。 -type MwFuture = Pin + Send>>; - -/// 中间件函数指针类型(fn 指针可命名 ⇒ 工厂函数的返回类型能写死)。 -type MwFn = fn(Request, Next) -> MwFuture; - -/// 405 / 413 改写中间件(挂在链尾的响应改写层)。 -/// -/// - **任何 405 都改写**成信封 body(契约 §6.5:405 ⇒ HTTP 405 + -/// `{code:405,msg:"方法不被允许",data:null}`)—— 🔴 **不看 body 是否为空**: -/// 「万一有 body 的 405 漏出非信封 body」是唯一的破口,不能留; -/// - **任何 413 都改写**成信封 body(传输状态码**保留** HTTP 413,body 换成 -/// `{code:413,msg:"请求体过大",data:null}`)—— 改写前 axum 默认吐的是 -/// `text/plain` 的 `Failed to buffer the request body: length limit exceeded` -/// ⇒ 服务端会冒出**第三种 body 形状**(契约 §2「没有第三种形状」的破口); -/// - **保留 `parts.headers`**(保住 `Allow` 头); -/// - 改写 `Content-Type` / `Content-Length`,body 换成对应信封。 -/// -/// 🔴 **非 405 / 非 413 的响应原样放行**(不改写)。 -/// 🔴 **不要**用 axum 的 `method_not_allowed_fallback` —— 它只对「调用那一刻已注册的路由」 -/// 生效,且**丢 `Allow` 头**。 -pub fn m_status_rewrite() -> axum::middleware::FromFnLayer { - axum::middleware::from_fn::<_, (Request,)>(m_status_rewrite_fn) -} - -fn m_status_rewrite_fn(req: Request, next: Next) -> MwFuture { - Box::pin(m_status_rewrite_inner(req, next)) -} - -async fn m_status_rewrite_inner(req: Request, next: Next) -> Response { - let res = next.run(req).await; - - // 只处理 405 / 413(其它状态码原样放行)。 - let (code, msg) = match res.status() { - StatusCode::METHOD_NOT_ALLOWED => (405, "方法不被允许"), - StatusCode::PAYLOAD_TOO_LARGE => (413, "请求体过大"), - _ => return res, - }; - // 🔴 **任何 405 / 413 都改写**(不看 body 是否为空)—— 契约要求这两类恒是信封 body。 - - // 🔴 `serde_json::to_vec` 对本结构体恒成功;真失败 ⇒ 保留原响应(不冒险改坏)。 - let Ok(bytes) = serde_json::to_vec(&envelope::fail(code, msg).0) else { - return res; - }; - - let (mut parts, body) = res.into_parts(); - drop(body); - parts - .headers - .insert(header::CONTENT_TYPE, HeaderValue::from_static("application/json")); - parts - .headers - .insert(header::CONTENT_LENGTH, HeaderValue::from(bytes.len())); - - Response::from_parts(parts, Body::from(bytes)) -} - -// ---------------------------------------------------------------- catch-all 中间件 - -/// catch-all 中间件 —— 把 handler 的 **panic** 变成 `HTTP 200 + {code:400, …}`。 -/// -/// 🔴 **只管 panic**:DB 报错**已在 handler 内部接住**(`sys.rs` / `crud.rs` 的 -/// `db_error(e, ctx)` ⇒ `fail(400, "系统异常,请联系管理员")` ⇒ HTTP 200 + code=400) -/// ⇒ **不要**在这里重新映射 DB 错误,也**不要**改任何 handler 的返回类型。 -/// -/// 🔴 依赖根 `Cargo.toml` 的 release profile **不设** `panic = "abort"` -/// (abort 下 `catch_unwind` 抓不到 panic ⇒ 进程直接死 ⇒ 客户端连接重置)。 -pub fn catch_all() -> axum::middleware::FromFnLayer { - axum::middleware::from_fn::<_, (Request,)>(catch_all_fn) -} - -fn catch_all_fn(req: Request, next: Next) -> MwFuture { - Box::pin(catch_all_inner(req, next)) -} - -async fn catch_all_inner(req: Request, next: Next) -> Response { - match CatchUnwind::new(next.run(req)).await { - Ok(resp) => resp, - Err(_) => Json(envelope::fail(400, "系统异常,请联系管理员").0).into_response(), - } -} - -/// 把 inner future 的 panic 变成 `Err`,**不引** `tower` / `tower-http` / `futures`。 -/// -/// 关键:`inner` 存成 `Pin>` ⇒ 本结构恒 `Unpin` ⇒ `get_mut()` 安全、**全程无需 `unsafe`**。 -struct CatchUnwind { - inner: Pin>, -} - -impl CatchUnwind { - fn new(inner: F) -> Self { - Self { - inner: Box::pin(inner), - } - } -} - -impl Future for CatchUnwind { - type Output = Result>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - // Self: Unpin ✔(`Pin>` 恒 Unpin) - let this = self.get_mut(); - let inner = &mut this.inner; - match catch_unwind(AssertUnwindSafe(|| inner.as_mut().poll(cx))) { - Ok(Poll::Pending) => Poll::Pending, - Ok(Poll::Ready(v)) => Poll::Ready(Ok(v)), - Err(e) => Poll::Ready(Err(e)), - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use std::path::PathBuf; - use std::sync::Arc; - - use tokio::io::{AsyncReadExt, AsyncWriteExt}; - use tokio::sync::OnceCell; - - use crate::platform::config::Config; - use crate::platform::db::Db; - use crate::platform::session::SessionStore; - - /// 全文件共享的临时库(pglite 进程级全局标志 ⇒ 只能开一次)。 - static DB: OnceCell = OnceCell::const_new(); - - async fn db() -> &'static Db { - DB.get_or_init(|| async { - let db = Db::open_temp().await.expect("打开 pglite 临时库失败"); - db.ensure_schema().await.expect("ensure_schema 失败"); - db - }) - .await - } - - fn new_state(db: &Db) -> AppState { - AppState { - config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-jnpf-lite-rust-routes-test"))), - db: Arc::new(db.clone()), - sessions: Arc::new(SessionStore::new()), - } - } - - /// 按**生产同一条链**造出完整 app(🔴 唯一真源 = [`build_app`],不在测试里抄一遍)。 - fn app(state: AppState) -> Router { - build_app(state) - } - - /// 起一个真实的 HTTP 服务(随机端口),返回端口号。 - 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, app(state)).await; - }); - // 让 server 任务有机会起来(它已经在跑,只是异步)。 - tokio::task::yield_now().await; - std::mem::forget(server); // 后台服务随测试进程退出而结束 - port - } - - /// 用裸 TCP 发一次请求,返回完整原始响应(头 + 体)。 - async fn raw(port: u16, request: &str) -> String { - let mut stream = tokio::net::TcpStream::connect(("127.0.0.1", port)) - .await - .expect("连接失败"); - stream - .write_all(request.as_bytes()) - .await - .expect("写请求失败"); - let mut buf = Vec::new(); - tokio::time::timeout( - std::time::Duration::from_secs(5), - stream.read_to_end(&mut buf), - ) - .await - .expect("HTTP 往返超时(5s)") - .expect("读响应失败"); - String::from_utf8_lossy(&buf).to_string() - } - - /// 发一个**超大 body** 的 POST,返回完整原始响应(头 + 体)。 - /// - /// 🔴 写 / 读的错误**必须容忍**:服务端判定 body 超限后会**立刻回 413**, - /// 并且**不再继续读**请求体 ⇒ 若客户端多写了,socket 上有未读数据 ⇒ - /// 服务端只能 RST(这正是真实客户端 curl 会看到的形态)。 - /// ⇒ 这里把 body 控制在「**刚好超过上限 1 字节**」, - /// 让服务端把 body 全部读走 ⇒ 干净 FIN ⇒ 响应能完整读到。 - async fn raw_oversized(port: u16, request: &str) -> String { - let mut stream = tokio::net::TcpStream::connect(("127.0.0.1", port)) - .await - .expect("连接失败"); - let _ = stream.write_all(request.as_bytes()).await; - let _ = stream.flush().await; - let mut buf = Vec::new(); - let mut tmp = [0u8; 16 * 1024]; - // 收尾读:容忍 `ECONNRESET`(服务端 RST)—— 已读到的字节照样能用。 - loop { - match tokio::time::timeout( - std::time::Duration::from_secs(2), - stream.read(&mut tmp), - ) - .await - { - Ok(Ok(0)) => break, - Ok(Ok(n)) => buf.extend_from_slice(&tmp[..n]), - Ok(Err(_)) => break, - Err(_) => break, - } - } - String::from_utf8_lossy(&buf).to_string() - } - - fn get(path: &str) -> String { - format!("GET {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n") - } - - /// 「错方法」探针用(本仓**没有任何**路由注册 `PATCH` ⇒ 必然方法不匹配)。 - fn patch(path: &str) -> String { - format!("PATCH {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n") - } - - /// 🔴 **带官方判别头的 GET** —— 官方前端发 `App-Code` / `Jnpf-Origin: pc` / - /// `Vue-Version: 3` 三个头(`jnpf-web-apps-main/src/api/request.ts:109-112`)。 - /// 本仓前端**只发前两个**、**不发** `Vue-Version` ⇒ 判别头零歧义。 - fn get_jnpf(path: &str) -> String { - format!( - "GET {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\ - App-Code: ssw-jnpf-lite-rust\r\nJnpf-Origin: pc\r\nVue-Version: 3\r\n\r\n" - ) - } - - /// 🔴 **带官方判别头的 POST**(body 必带 `Content-Length`)。 - fn post_jnpf(path: &str, body: &str) -> String { - format!( - "POST {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\ - Content-Type: application/json\r\n\ - App-Code: ssw-jnpf-lite-rust\r\nJnpf-Origin: pc\r\nVue-Version: 3\r\n\ - Content-Length: {}\r\n\r\n{body}", - body.len() - ) - } - - /// 带 body 的 PUT(`Content-Length` 必须给对,否则服务端会等)。 - fn put_req(path: &str, body: &str, jnpf: bool) -> String { - let extra = if jnpf { - "App-Code: ssw-jnpf-lite-rust\r\nJnpf-Origin: pc\r\nVue-Version: 3\r\n" - } else { - "" - }; - format!( - "PUT {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\ - Content-Type: application/json\r\n{extra}Content-Length: {}\r\n\r\n{body}", - body.len() - ) - } - - /// 未注册的路径 ⇒ **HTTP 404** + `{code:404,msg:"接口不存在",data:null}`。 - #[tokio::test] - async fn unknown_route_returns_http_404_with_envelope() { - let port = serve(new_state(db().await)).await; - let raw = raw(port, &get("/api/not-exist-xyz")).await; - - assert!( - raw.starts_with("HTTP/1.1 404 Not Found"), - "未知路由必须是 HTTP 404,实际: {raw}" - ); - let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 404); - assert_eq!(body["msg"], "接口不存在"); - assert_eq!(body["data"], Value::Null); - } - - /// 路径存在、方法不对 ⇒ **HTTP 405** + `{code:405,…}` + **保留 `Allow` 头**。 - #[tokio::test] - async fn wrong_method_returns_http_405_with_allow_header() { - let port = serve(new_state(db().await)).await; - let raw = raw(port, &get("/api/oauth/Login")).await; - - assert!( - raw.starts_with("HTTP/1.1 405 Method Not Allowed"), - "方法不对必须是 HTTP 405,实际: {raw}" - ); - let (head, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - assert!( - head.to_ascii_lowercase().contains("allow: post"), - "405 必须保留 Allow 头,实际头: {head}" - ); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 405); - assert_eq!(body["msg"], "方法不被允许"); - assert_eq!(body["data"], Value::Null); - } - - /// 🔴 **超大 body ⇒ HTTP 413 + 信封**(契约 §2「没有第三种形状」)。 - /// - /// axum 的默认 body 上限是 2MB ⇒ 这里发**刚好超过 1 字节**的 JSON。 - /// 改写前服务端会吐 `text/plain` 的 `Failed to buffer the request body: length limit exceeded` - /// ⇒ 那就是**第三种 body 形状** ⇒ 必须被归一成信封。 - #[tokio::test] - async fn oversized_body_returns_http_413_with_envelope() { - let port = serve(new_state(db().await)).await; - // axum 默认 body 上限 = 2MB(2*1024*1024 字节)⇒ 这里发**刚好超过 1 字节**的 JSON。 - // 🔴 刻意不做「远远超过」:多写的字节服务端不会读 ⇒ socket 残留未读数据 ⇒ RST ⇒ 响应读不全。 - const LIMIT: usize = 2 * 1024 * 1024; - let prefix = "{\"account\":\"big_user\",\"password\":\"x\",\"realName\":\""; - let suffix = "\"}"; - let padding = "a".repeat(LIMIT + 1 - prefix.len() - suffix.len()); - let payload = format!("{prefix}{padding}{suffix}"); - assert_eq!(payload.len(), LIMIT + 1); - let req = format!( - "POST /api/ssw/sys/User/Save HTTP/1.1\r\nHost: localhost\r\n\ - Content-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", - payload.len(), - payload - ); - let raw = raw_oversized(port, &req).await; - - assert!( - raw.starts_with("HTTP/1.1 413 Payload Too Large"), - "超大 body 必须是 HTTP 413,实际: {}", - &raw[..raw.len().min(400)] - ); - let (head, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - assert!( - head.to_ascii_lowercase() - .contains("content-type: application/json"), - "413 必须是 JSON 信封,实际头: {head}" - ); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 413); - assert_eq!(body["msg"], "请求体过大"); - assert_eq!(body["data"], Value::Null); - } - - /// 🔴 **路由表钉子测试** —— 27 条路径一条都不许少、一条都不许拼错。 - /// - /// 用「错方法 ⇒ 405」当作「这条路径确实注册了」的探针(比逐条调真接口便宜, - /// 且不依赖鉴权 / 数据);路径没注册 ⇒ 404。 - /// - /// 🔴 **业务路径取自业务层**([`crate::modules::ALL_ROUTES`])—— 平台层不认业务路径 - /// ⇒ 加业务模块**不用改本文件**(业务模块的路由表在 `modules/.rs`)。 - #[tokio::test] - async fn route_table_is_pinned() { - let port = serve(new_state(db().await)).await; - - /// 平台层的 18 条已注册路径(照抄 [`build_router`] 的注册表,逐字)。 - const REGISTERED: [&str; 18] = [ - "/api/health", - "/api/oauth/Login", - "/api/oauth/CurrentUser", - "/api/ssw/sys/User/List", - "/api/ssw/sys/User/Save", - "/api/ssw/sys/User/Delete", - "/api/ssw/sys/Role/List", - "/api/ssw/sys/Role/Save", - "/api/ssw/sys/Role/Delete", - "/api/ssw/sys/Role/Modules", - "/api/ssw/sys/Organize/List", - "/api/ssw/sys/Organize/Save", - "/api/ssw/sys/Organize/Delete", - "/api/ssw/sys/Module/List", - "/api/ssw/sys/Module/Save", - "/api/ssw/sys/Module/Delete", - "/api/permission/Authority/Data/any-id", - "/api/permission/Authority/RoleModules", - ]; - - for path in REGISTERED { - let raw = raw(port, &patch(path)).await; - assert!( - raw.starts_with("HTTP/1.1 405 Method Not Allowed"), - "路由表必须包含 {path}(方法不对 ⇒ 405),实际: {raw}" - ); - } - - // 业务层的 9 条(demo / shop / books)—— 取自业务层的路由表。 - for path in crate::modules::ALL_ROUTES { - let raw = raw(port, &patch(path)).await; - assert!( - raw.starts_with("HTTP/1.1 405 Method Not Allowed"), - "业务路由表必须包含 {path}(方法不对 ⇒ 405),实际: {raw}" - ); - } - - // 没注册过的路径 ⇒ 404(把「404 兜底」也钉在这条测试里)。 - let raw = raw(port, &patch("/api/__nope__/xyz")).await; - assert!( - raw.starts_with("HTTP/1.1 404 Not Found"), - "未注册的路径必须是 404,实际: {raw}" - ); - } - - /// 🔴 **非 405 响应原样穿过改写中间件**(状态 200 + 信封 + `application/json`)。 - #[tokio::test] - async fn non_405_response_passes_through_untouched() { - let port = serve(new_state(db().await)).await; - let raw = raw(port, &get("/api/health")).await; - - assert!( - raw.starts_with("HTTP/1.1 200 OK"), - "健康检查必须返回 200,实际: {raw}" - ); - let (head, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - assert!( - head.to_ascii_lowercase() - .contains("content-type: application/json"), - "健康检查必须返回 JSON,实际头: {head}" - ); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["ok"], true); - } - - /// panic ⇒ **HTTP 200** + `{code:400,msg:"系统异常,请联系管理员",data:null}`。 - #[tokio::test] - async fn panic_is_converted_to_http_200_code_400() { - let port = serve(new_state(db().await)).await; - let raw = raw(port, &get("/api/__test__/panic")).await; - - assert!( - raw.starts_with("HTTP/1.1 200 OK"), - "panic 必须被 catch-all 接住并返回 HTTP 200,实际: {raw}" - ); - let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 400); - assert_eq!(body["msg"], "系统异常,请联系管理员"); - assert_eq!(body["data"], Value::Null); - } - - /// 🔴 DDL 绝不可从 HTTP 下载(契约 §R1.9)—— 两条路径都必须是 404 + 信封。 - #[tokio::test] - async fn ddl_is_never_downloadable() { - let port = serve(new_state(db().await)).await; - for path in ["/db/schema.sql", "/src/backend/db/schema.sql"] { - let raw = raw(port, &get(path)).await; - assert!( - raw.starts_with("HTTP/1.1 404 Not Found"), - "{path} 必须返回 HTTP 404,实际: {raw}" - ); - let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 404); - assert_eq!(body["msg"], "接口不存在"); - } - } - - /// `/api/health` ⇒ HTTP 200 + `{ok, tables, version}`(探活,契约 §6.5 末条)。 - #[tokio::test] - async fn health_reports_ok_tables_and_version() { - let port = serve(new_state(db().await)).await; - let raw = raw(port, &get("/api/health")).await; - - assert!( - raw.starts_with("HTTP/1.1 200 OK"), - "探活必须永远有响应,实际: {raw}" - ); - let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["ok"], true); - assert_eq!(body["tables"], 10); - assert_eq!(body["version"], env!("CARGO_PKG_VERSION")); - } - - // ---- 面 B(官方 JNPF 契约面)---- - - /// 🔴 **面 B 的 5 条官方路由必须已注册**(错方法 ⇒ 405)—— 逐字钉死。 - /// - /// 🔴 **面 A 的 27 条路由表一个字都没动**(见上面的 `route_table_is_pinned`)—— - /// 面 B 全部是**新增**路径,唯一共用的是 `CurrentUser` / `Authority/Data`。 - #[tokio::test] - async fn jnpf_route_table_is_pinned() { - let port = serve(new_state(db().await)).await; - - const JNPF_REGISTERED: [&str; 5] = [ - "/api/permission/Users", - "/api/permission/Role", - "/api/permission/Organize/AsyncList/0", - "/api/system/Menu/ModuleBySystem", - "/api/permission/Authority/Data/any-id/Values", - ]; - - for path in JNPF_REGISTERED { - let raw = raw(port, &patch(path)).await; - assert!( - raw.starts_with("HTTP/1.1 405 Method Not Allowed"), - "面 B 路由表必须包含 {path}(方法不对 ⇒ 405),实际: {raw}" - ); - } - } - - /// 🔴 **面 A 与面 B 的 `Authority/Data` 必须共存**: - /// - 面 A:`PUT /api/permission/Authority/Data/{objectId}`; - /// - 面 B:`POST /api/permission/Authority/Data/{objectId}/Values`。 - /// - /// matchit 0.8.4 允许「静态段跟在参数节点后」⇒ 两条可同时注册 - /// (若冲突,`build_router` 在建路由时就会 panic ⇒ 测试直接炸)。 - #[tokio::test] - async fn surface_a_and_b_authority_paths_coexist() { - let port = serve(new_state(db().await)).await; - - // 面 A 的 PUT:未登录 ⇒ `code=600`(**不是** 404 / 405)。 - let resp = raw( - port, - &put_req("/api/permission/Authority/Data/any-id", "{}", false), - ) - .await; - let (_, body) = resp.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 600, "面 A 未登录必须是 600,实际: {body}"); - - // 面 B 的 POST:未登录 ⇒ `code=602`(官方前端只对 601/602 清 token)。 - let resp = raw( - port, - &post_jnpf("/api/permission/Authority/Data/any-id/Values", "{}"), - ) - .await; - let (_, body) = resp.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 602, "面 B 未登录必须是 602,实际: {body}"); - } - - /// 🔴 **判别头分流钉死**:`CurrentUser` 未登录时 —— 面 A 返 `600`、面 B 返 `602`。 - #[tokio::test] - async fn current_user_routes_by_discriminator_header() { - let port = serve(new_state(db().await)).await; - - // 面 A(无判别头)⇒ 600。 - let resp = raw(port, &get("/api/oauth/CurrentUser")).await; - let (_, body) = resp.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 600, "面 A 未登录必须是 600,实际: {body}"); - - // 面 B(`Vue-Version: 3`)⇒ 602。 - let resp = raw(port, &get_jnpf("/api/oauth/CurrentUser")).await; - let (_, body) = resp.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 602, "面 B 未登录必须是 602,实际: {body}"); - } - - /// 🔴 **面 B 的官方端点未登录时一律 602**(不是 600、不是 404、不是 405)。 - #[tokio::test] - async fn jnpf_endpoints_return_602_without_token() { - let port = serve(new_state(db().await)).await; - - for path in [ - "/api/permission/Users", - "/api/permission/Role", - "/api/permission/Organize/AsyncList/0", - "/api/system/Menu/ModuleBySystem", - ] { - let raw = raw(port, &get_jnpf(path)).await; - assert!( - raw.starts_with("HTTP/1.1 200 OK"), - "{path} 未登录也必须 HTTP 200 + 信封,实际: {raw}" - ); - let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 602, "{path} 未登录必须是 602,实际: {body}"); - } - } -} diff --git a/src/backend/tests/auth_it.rs b/src/backend/tests/auth_it.rs deleted file mode 100644 index c2cfb57..0000000 --- a/src/backend/tests/auth_it.rs +++ /dev/null @@ -1,543 +0,0 @@ -//! auth 集成测试 —— 登录 / 当前用户 / 两个守卫。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** -//! (`OnceCell` 起一次),不每个测试函数各开一个。 -//! -//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 -//! `#[tokio::test]` **并发**跑(不同线程)⇒ 共用一个库时它们会互相踩数据。 -//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 -//! 🔴 **不依赖测试执行顺序**:每个测试自己造前置条件(自己的 token / 自己的用户)。 - -use std::path::PathBuf; -use std::sync::Arc; - -use axum::body::Bytes; -use axum::http::{HeaderMap, HeaderValue}; -use axum::Json; -use ssw_jnpf_lite_rust::platform::auth::{ - current_user, login, login_from_bytes, require_login, require_module, LoginForm, -}; -use ssw_jnpf_lite_rust::platform::cipher::{encrypt_password, md5_hex}; -use ssw_jnpf_lite_rust::platform::config::Config; -use ssw_jnpf_lite_rust::platform::db::Db; -use ssw_jnpf_lite_rust::platform::envelope::ActionResult; -use ssw_jnpf_lite_rust::platform::ids::new_uuid; -use ssw_jnpf_lite_rust::bootstrap::ensure_base; -use ssw_jnpf_lite_rust::platform::seed::first_seed; -use ssw_jnpf_lite_rust::platform::session::{SessionStore, TokenUser}; -use ssw_jnpf_lite_rust::platform::state::AppState; -use tokio::sync::{Mutex, OnceCell}; - -/// 全文件共享的临时库。 -static DB: OnceCell = OnceCell::const_new(); - -/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 -static LOCK: Mutex<()> = Mutex::const_new(()); - -/// 管理员账号(契约 §8.6 的 `admin`)。 -const ADMIN_ACCOUNT: &str = "admin"; - -/// 管理员口令(契约 §8.6:种子口令 `123456`)。 -const ADMIN_PLAIN: &str = "123456"; - -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 -} - -/// 造一个应用状态(**每个测试自己一份** ⇒ token 表互不干扰)。 -fn new_state(db: &Db) -> AppState { - AppState { - config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-jnpf-lite-rust-auth-it"))), - db: Arc::new(db.clone()), - sessions: Arc::new(SessionStore::new()), - } -} - -/// 带 `bearer ` 的请求头。 -fn auth_headers(token: &str) -> HeaderMap { - let mut headers = HeaderMap::new(); - let value = - HeaderValue::from_str(&format!("bearer {}", token)).expect("token 必须是合法 header 值"); - headers.insert("authorization", value); - headers -} - -/// 守卫的**失败**分支(`ActionResult` / `TokenUser` 都不实现 `Debug` ⇒ 不用 `expect_err`)。 -fn expect_guard_err(res: Result>, ctx: &str) -> ActionResult { - match res { - Ok(_) => panic!("{ctx}:必须失败,却放行了"), - Err(e) => e.0, - } -} - -/// 守卫的**放行**分支。 -fn expect_guard_ok(res: Result>, ctx: &str) -> TokenUser { - match res { - Ok(user) => user, - Err(e) => panic!( - "{ctx}:必须放行,实际 code={} msg={}", - e.0.code, e.0.msg - ), - } -} - -/// 造一个**非管理员**用户(口令 `123456`),返回它的 id。 -async fn insert_plain_user(db: &Db, account: &str) -> String { - let id = new_uuid(); - let password = md5_hex(ADMIN_PLAIN); - let is_admin = "0".to_string(); - let delete_mark = "0".to_string(); - let params: [&(dyn ssw_jnpf_lite_rust::platform::db::pglite::ToSql + Sync); 5] = [ - &id, - &account.to_string(), - &password, - &is_admin, - &delete_mark, - ]; - db.exec_params( - "INSERT INTO base_user \ - (f_id, f_account, f_password, f_is_administrator, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text::integer, '0')", - ¶ms, - ) - .await - .expect("插入测试用户失败"); - id -} - -/// 把 `base_user` 的**表 + 二级索引**从 `schema.sql` 里捞出来重建(测试专用)。 -/// -/// 🔴 **整词匹配**:只捞「`CREATE TABLE base_user (`」与「`CREATE INDEX … ON base_user(`」。 -/// 绝不能用 `contains("base_user")` —— 那会**误伤 `base_user_relation`**(名字里也含 `base_user`)。 -/// 🔴 **必须连二级索引一起恢复**:`DROP TABLE` 会连带删掉索引 `i_bu_fa`, -/// 只重建表 ⇒ 索引**静默**丢失。 -async fn restore_base_user(db: &Db) { - let mut ddl: Vec = Vec::new(); - for stmt in ssw_jnpf_lite_rust::platform::db::split_sql_statements(ssw_jnpf_lite_rust::platform::db::SCHEMA_SQL) { - let head = stmt.trim_start(); - let is_table = head.starts_with("CREATE TABLE base_user ("); - let is_index = head.starts_with("CREATE INDEX") && head.contains(" ON base_user("); - if is_table || is_index { - ddl.push(stmt); - } - } - assert_eq!( - ddl.len(), - 2, - "schema.sql 里必须恰好有 base_user 的建表 + 索引两条:{ddl:?}" - ); - for stmt in ddl { - db.exec(&stmt).await.expect("恢复 base_user 失败"); - } -} - -// ---- 登录 ---- - -/// 空 body ⇒ `code=400`、`msg="缺少 account / password"`。 -/// -/// 🔴 空 body **能**解析成功(`serde_urlencoded::from_bytes::(b"")` 返 `Ok`, -/// 三个字段全 `None`)⇒ 本条钉的是「**解析成功但 account/password 缺失**」这条分支。 -/// 「**整个 body 解析失败**」那条分支由 `login_with_unparsable_body_fails` 单独钉住。 -#[tokio::test] -async fn login_with_empty_body_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let res = login_from_bytes(&state, Bytes::new()).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "缺少 account / password"); - assert_eq!(res.0.data, serde_json::Value::Null); -} - -/// 🔴 **整个 body 解析失败** ⇒ 同样 `400 "缺少 account / password"`(不是 axum 默认的 400 文本)。 -/// -/// 用**重复键**(`account=a&account=b`)触发 serde 的 `duplicate field` 错误。 -/// 先单独断言 `from_bytes` **确实**返 `Err` ⇒ 将来 serde 行为变了这条测试会**响亮地挂掉**, -/// 而不是悄悄变成空转。 -#[tokio::test] -async fn login_with_unparsable_body_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - // 前置条件:重复键 ⇒ serde 派生的 struct visitor 报 `duplicate field \`account\``。 - assert!( - serde_urlencoded::from_bytes::(b"account=a&account=b").is_err(), - "重复键必须让 serde_urlencoded 解析失败(否则本测试是空转)" - ); - - let res = login_from_bytes(&state, Bytes::from_static(b"account=a&account=b")).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "缺少 account / password"); - assert_eq!(res.0.data, serde_json::Value::Null); -} - -/// 🔴 **校验顺序**:缺 `password` **且** `grant_type=foo` ⇒ 必须是「缺少 account / password」。 -/// -/// 顺序 1(缺 account/password)先于顺序 2(grant_type 不支持) -/// ⇒ 缺 password 时**永远**看不到 `不支持的 grant_type`。 -/// (把 1、2 调换 ⇒ 本条测试会挂。) -#[tokio::test] -async fn login_checks_missing_credentials_before_unsupported_grant_type() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let res = login_from_bytes( - &state, - Bytes::from_static(b"account=admin&grant_type=foo"), - ) - .await; - assert_eq!(res.0.code, 400); - assert_eq!( - res.0.msg, "缺少 account / password", - "校验顺序 1 必须先于顺序 2" - ); -} - -/// 解析成功但 `account` / `password` 缺一 ⇒ 同样 `400 "缺少 account / password"`。 -#[tokio::test] -async fn login_without_credentials_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - // 只有 account,没有 password。 - let res = login_from_bytes(&state, Bytes::from_static(b"account=admin")).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "缺少 account / password"); - - // 已解析的表单走同一条分支。 - let res = login( - &state, - LoginForm { - account: Some(ADMIN_ACCOUNT.to_string()), - password: None, - grant_type: None, - }, - ) - .await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "缺少 account / password"); -} - -/// `grant_type=foo` ⇒ `code=400`、`msg="不支持的 grant_type"`。 -#[tokio::test] -async fn login_with_unsupported_grant_type_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let body = format!( - "account={}&password={}&grant_type=foo", - ADMIN_ACCOUNT, - encrypt_password(ADMIN_PLAIN) - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "不支持的 grant_type"); -} - -/// 口令错 ⇒ `code=400`、`msg="账号或密码错误"`。 -#[tokio::test] -async fn login_with_wrong_password_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let body = format!( - "account={}&password={}&grant_type=password", - ADMIN_ACCOUNT, - encrypt_password("wrong-password") - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "账号或密码错误"); -} - -/// 🔴 密文非法(非法 hex)⇒ **同一条** `400 "账号或密码错误"`(不许另造文案)。 -#[tokio::test] -async fn login_with_invalid_ciphertext_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let body = format!("account={}&password=not-hex&grant_type=password", ADMIN_ACCOUNT); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "账号或密码错误"); -} - -/// 账号不存在 ⇒ `code=400`、`msg="账号或密码错误"`。 -#[tokio::test] -async fn login_with_unknown_account_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let body = format!( - "account=auth_it_no_such_user&password={}&grant_type=password", - encrypt_password(ADMIN_PLAIN) - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "账号或密码错误"); -} - -/// 口令正确 ⇒ `code=200`,`data.token` 非空、`expiresIn==7200`、`tokenTypeName=="bearer"`。 -#[tokio::test] -async fn login_with_correct_password_succeeds() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let body = format!( - "account={}&password={}&grant_type=password", - ADMIN_ACCOUNT, - encrypt_password(ADMIN_PLAIN) - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 200); - assert_eq!(res.0.msg, "成功"); - - let data = res.0.data.as_object().expect("data 必须是对象"); - let token = data["token"].as_str().expect("token 必须是字符串"); - assert!(!token.is_empty(), "token 不得为空"); - assert_eq!(data["expiresIn"], serde_json::json!(7200)); - assert_eq!(data["tokenTypeName"], serde_json::json!("bearer")); - - // 🔴 口令**不得外泄**:响应里不得出现密文或 md5。 - let serialized = serde_json::to_string(&res.0.data).unwrap(); - assert!( - !serialized.contains(&encrypt_password(ADMIN_PLAIN)), - "响应里不得回显密文" - ); - assert!( - !serialized.contains(&md5_hex(ADMIN_PLAIN)), - "响应里不得回显口令摘要" - ); -} - -/// 🔴 `grant_type` **缺失是允许的**(只有「存在且 ≠ password」才失败)。 -#[tokio::test] -async fn login_without_grant_type_is_allowed() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let body = format!( - "account={}&password={}", - ADMIN_ACCOUNT, - encrypt_password(ADMIN_PLAIN) - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 200, "缺 grant_type 必须放行"); -} - -/// 🔴 **DB 报错** ⇒ `code=400`、`msg="系统异常,请联系管理员"`(契约 §R1.2 / §6.5)。 -/// -/// 🔴 **不是** `"账号或密码错误"` —— DB 挂了不该伪装成「你密码错了」: -/// 用户会反复重试、运维也看不到告警信号;两条消息必须能区分。 -#[tokio::test] -async fn login_with_db_error_returns_system_error_message() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - // 造前置条件:把 base_user 删掉 ⇒ 查用户这条 SQL 必然失败。 - db.exec("DROP TABLE base_user").await.expect("临时删表失败"); - - let body = format!( - "account={}&password={}&grant_type=password", - ADMIN_ACCOUNT, - encrypt_password(ADMIN_PLAIN) - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - - // 🔴 **先恢复表(含二级索引)+ 重跑种子,再断言** —— - // 恢复必须在本测试内做完,断言失败也不能污染同文件的其它测试。 - restore_base_user(db).await; - ensure_base(db).await.expect("恢复后 ensure_base 失败"); - first_seed(db, "123456").await.expect("恢复后 first_seed 失败"); - - assert_eq!(res.0.code, 400); - assert_eq!(res.0.msg, "系统异常,请联系管理员"); - assert_ne!( - res.0.msg, "账号或密码错误", - "DB 报错不得伪装成口令错" - ); - - // 恢复后 admin 用户必须重新可登录(证明表 + 种子真的回来了)。 - let body = format!( - "account={}&password={}&grant_type=password", - ADMIN_ACCOUNT, - encrypt_password(ADMIN_PLAIN) - ); - let res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(res.0.code, 200, "恢复后 admin 必须能登录"); -} - -// ---- CurrentUser ---- - -/// CurrentUser 无 token ⇒ `code=600`、`msg="未登录"`。 -#[tokio::test] -async fn current_user_without_token_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let res = current_user(&state, HeaderMap::new()).await; - assert_eq!(res.0.code, 600); - assert_eq!(res.0.msg, "未登录"); - assert_eq!(res.0.data, serde_json::Value::Null); -} - -/// CurrentUser 有 token ⇒ `code=200`,`userInfo` 形状正确、`menuList` 是 4 个根菜单的数组。 -#[tokio::test] -async fn current_user_with_token_returns_user_info_and_menu() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - // 先登录拿 token。 - let body = format!( - "account={}&password={}&grant_type=password", - ADMIN_ACCOUNT, - encrypt_password(ADMIN_PLAIN) - ); - let login_res = login_from_bytes(&state, Bytes::from(body)).await; - assert_eq!(login_res.0.code, 200); - let token = login_res.0.data["token"] - .as_str() - .expect("token 必须是字符串") - .to_string(); - - let res = current_user(&state, auth_headers(&token)).await; - assert_eq!(res.0.code, 200); - - let data = res.0.data.as_object().expect("data 必须是对象"); - let user_info = data["userInfo"].as_object().expect("userInfo 必须是对象"); - assert_eq!(user_info["userAccount"], serde_json::json!("admin")); - assert_eq!(user_info["userName"], serde_json::json!("admin")); - assert!( - user_info["isAdministrator"].is_boolean(), - "isAdministrator 必须是 JSON 布尔:{:?}", - user_info["isAdministrator"] - ); - assert_eq!(user_info["isAdministrator"], serde_json::json!(true)); - assert!( - user_info["userId"].as_str().is_some_and(|s| !s.is_empty()), - "userId 必须是非空字符串" - ); - - let menu = data["menuList"].as_array().expect("menuList 必须是数组"); - assert_eq!(menu.len(), 4, "管理员应看到 4 个根菜单"); -} - -// ---- 守卫 ---- - -/// `require_login`:无 token ⇒ `code=600`。 -#[tokio::test] -async fn require_login_without_token_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let err = expect_guard_err( - require_login(&state, &HeaderMap::new()).await, - "无 token 的 require_login", - ); - assert_eq!(err.code, 600); - assert_eq!(err.msg, "未登录"); -} - -/// `require_login`:有 token ⇒ `Ok(TokenUser)`(账号 = admin)。 -#[tokio::test] -async fn require_login_with_token_succeeds() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let token = state.sessions.issue(ADMIN_ACCOUNT, "auth_it_uid", 1); - let user = expect_guard_ok( - require_login(&state, &auth_headers(&token)).await, - "有 token 的 require_login", - ); - assert_eq!(user.account, ADMIN_ACCOUNT); - assert_eq!(user.is_admin, 1); -} - -/// `require_module`:无 token ⇒ `code=600`(**先**判登录)。 -#[tokio::test] -async fn require_module_without_token_fails() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let err = expect_guard_err( - require_module(&state, &HeaderMap::new(), "system/User").await, - "无 token 的 require_module", - ); - assert_eq!(err.code, 600); - assert_eq!(err.msg, "未登录"); -} - -/// `require_module`:管理员短路放行(不需要任何授权行)。 -#[tokio::test] -async fn require_module_allows_administrator() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let token = state.sessions.issue(ADMIN_ACCOUNT, "auth_it_admin_uid", 1); - let user = expect_guard_ok( - require_module(&state, &auth_headers(&token), "system/User").await, - "管理员的 require_module", - ); - assert_eq!(user.account, ADMIN_ACCOUNT); -} - -/// `require_module`:非管理员 + 菜单已映射 + 无授权 ⇒ `code=403`。 -#[tokio::test] -async fn require_module_denies_plain_user_without_grant() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let account = "auth_it_plain_user"; - let user_id = insert_plain_user(db, account).await; - let token = state.sessions.issue(account, &user_id, 0); - - let err = expect_guard_err( - require_module(&state, &auth_headers(&token), "system/User").await, - "非管理员无授权的 require_module", - ); - assert_eq!(err.code, 403); - assert_eq!(err.msg, "无菜单权限"); -} - -/// `require_module`:菜单**未映射** ⇒ 放行(对齐 `SswPermissionGuard` 的 warn 路径)。 -#[tokio::test] -async fn require_module_allows_unmapped_module_key() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let account = "auth_it_unmapped_user"; - let user_id = insert_plain_user(db, account).await; - let token = state.sessions.issue(account, &user_id, 0); - - expect_guard_ok( - require_module(&state, &auth_headers(&token), "not/mapped/anywhere").await, - "未映射 key 的 require_module", - ); -} diff --git a/src/backend/tests/crud_it.rs b/src/backend/tests/crud_it.rs deleted file mode 100644 index f879a1b..0000000 --- a/src/backend/tests/crud_it.rs +++ /dev/null @@ -1,853 +0,0 @@ -//! crud 集成测试 —— spec 驱动的通用 CRUD 引擎 + demo / shop / books 三个业务模块。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** -//! (`OnceCell` 起一次),不每个测试函数各开一个(裁决 S11)。 -//! -//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 -//! `#[tokio::test]` **并发**跑 ⇒ 共用一个库时它们会互相踩数据 -//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 -//! -//! 🔴 **不依赖测试执行顺序**:每个测试用**自己专属**的标题 / id; -//! 需要「不存在」前置条件的 ⇒ 自己先 `DELETE` 造出前置条件再断言。 - -use std::path::PathBuf; -use std::sync::Arc; - -use axum::body::Bytes; -use axum::extract::{RawQuery, State}; -use axum::http::{HeaderMap, HeaderValue}; -use serde_json::{json, Value}; -use ssw_jnpf_lite_rust::bootstrap::ensure_base; -use ssw_jnpf_lite_rust::platform::config::Config; -use ssw_jnpf_lite_rust::modules::{books, demo, shop}; -use ssw_jnpf_lite_rust::platform::db::Db; -use axum::Json; -use ssw_jnpf_lite_rust::platform::envelope::ActionResult; -use ssw_jnpf_lite_rust::platform::seed::first_seed; -use ssw_jnpf_lite_rust::platform::session::SessionStore; -use ssw_jnpf_lite_rust::platform::state::AppState; -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 -} - -/// 造一个应用状态(**每个测试自己一份** ⇒ token 表互不干扰)。 -fn new_state(db: &Db) -> AppState { - AppState { - config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-jnpf-lite-rust-crud-it"))), - db: Arc::new(db.clone()), - sessions: Arc::new(SessionStore::new()), - } -} - -/// 取种子 admin 的用户 id。 -async fn admin_id(db: &Db) -> String { - let rows = db - .query_json("SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1") - .await - .expect("查 admin 失败"); - rows.first() - .and_then(|r| r.get("id")) - .and_then(Value::as_str) - .expect("种子里必须有 admin 用户") - .to_string() -} - -/// 造一个**管理员** token(管理员短路 ⇒ 菜单守卫直接放行)。 -async fn admin_state(db: &Db) -> (AppState, HeaderMap) { - let state = new_state(db); - let id = admin_id(db).await; - let token = state.sessions.issue("admin", &id, 1); - (state, auth_headers(&token)) -} - -/// 造一个**非管理员** token(`f_is_administrator = 0`、**无任何授权**)。 -/// -/// 🔴 用来验证「菜单守卫真的会拦人」(裁决 S15):`shop/Product` 与 `books/Book` -/// 这两个菜单 key 已由种子写入 `base_module` ⇒ 非管理员没授权 ⇒ `code=403`。 -async fn plain_user_state(db: &Db) -> (AppState, HeaderMap) { - let state = new_state(db); - let user_id = "it_crud_plain_user"; - db.exec(&format!( - "DELETE FROM base_user WHERE f_id = '{user_id}'; \ - INSERT INTO base_user (f_id, f_account, f_password, f_is_administrator, \ - f_enabled_mark, f_delete_mark) \ - VALUES ('{user_id}', '{user_id}', 'x', 0, 1, 0)" - )) - .await - .expect("造非管理员用户失败"); - let token = state.sessions.issue(user_id, user_id, 0); - (state, auth_headers(&token)) -} - -/// 带 `bearer ` 的请求头。 -fn auth_headers(token: &str) -> HeaderMap { - let mut headers = HeaderMap::new(); - let value = - HeaderValue::from_str(&format!("bearer {}", token)).expect("token 必须是合法 header 值"); - headers.insert("authorization", value); - headers -} - -/// 空请求头(未登录)。 -fn anon_headers() -> HeaderMap { - HeaderMap::new() -} - -/// 造一个 query。 -fn query(raw: &str) -> RawQuery { - RawQuery(Some(raw.to_string())) -} - -/// 造一个**完全没有 query** 的 `RawQuery`(`RawQuery(None)`)。 -fn query_none() -> RawQuery { - RawQuery(None) -} - -/// 信封的 `data` 必须是对象。 -fn data_obj(r: &Json) -> Value { - assert_eq!(r.0.code, 200, "期望成功,实际 code={}", r.0.code); - r.0.data.clone() -} - -/// 信封的 `data` 必须是数组。 -fn data_arr(r: &Json) -> Vec { - assert_eq!(r.0.code, 200, "期望成功,实际 code={}", r.0.code); - r.0.data.as_array().expect("data 必须是数组").clone() -} - -// ---------------------------------------------------------------- Product - -/// 新建 Product ⇒ `data.id` 长度 36、**`data.price == "9.90"`(字符串)**。 -#[tokio::test] -async fn product_save_creates_product_with_price_as_string() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-产品-1"; - db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = shop::product_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title, "price": "9.90"}).to_string()), - ) - .await; - let data = data_obj(&r); - - let id = data["id"].as_str().expect("id 必须是字符串"); - assert_eq!(id.len(), 36, "主键必须是 36 位 UUID: {id}"); - assert_eq!(data["title"], title); - // 🔴 numeric 列必须序列化成**字符串**(`f_price::text`)。 - assert_eq!(data["price"], "9.90", "price 必须是字符串 9.90"); - assert!(data["price"].is_string(), "price 必须是 JSON 字符串"); - assert_eq!(data["creatorUserId"], "admin"); - assert_eq!(data["deleteMark"], 0); - assert!(data["creatorTime"].is_string(), "creatorTime 必须是 ISO 串"); - assert!(data["creatorTime"].as_str().unwrap().ends_with('Z')); -} - -/// Product 的 `creatorUserId` 取 body(缺省才回落 `'admin'`)。 -#[tokio::test] -async fn product_creator_user_id_comes_from_body() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-产品-2"; - db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = shop::product_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title, "creatorUserId": "someone"}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["creatorUserId"], "someone"); -} - -/// 路径 1:body 不给 price ⇒ 用 spec 的默认值 `'0.00'`。 -#[tokio::test] -async fn product_price_defaults_to_zero() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-产品-3"; - db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = shop::product_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["price"], "0.00", "缺省 price 必须是 0.00"); -} - -// ---------------------------------------------------------------- Book - -/// 新建 Book(6 个业务字段)⇒ `price == "58.00"`(字符串)、`stock == 100`(**数字**)。 -#[tokio::test] -async fn book_save_creates_book_with_string_price_and_numeric_stock() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-书-1"; - db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = books::book_save( - State(state.clone()), - headers, - Bytes::from( - json!({ - "title": title, - "author": "作者甲", - "isbn": "9780000000001", - "category": "技术", - "price": "58.00", - "stock": 100 - }) - .to_string(), - ), - ) - .await; - let data = data_obj(&r); - - assert_eq!(data["id"].as_str().unwrap().len(), 36); - assert_eq!(data["title"], title); - assert_eq!(data["author"], "作者甲"); - assert_eq!(data["isbn"], "9780000000001"); - assert_eq!(data["category"], "技术"); - assert_eq!(data["price"], "58.00", "price 必须是字符串"); - assert!(data["price"].is_string()); - // 🔴 int 列保持**数字**。 - assert_eq!(data["stock"], 100); - assert!(data["stock"].is_number(), "stock 必须是 JSON 数字"); - assert_eq!(data["creatorUserId"], "admin"); - assert_eq!(data["deleteMark"], 0); -} - -/// 路径 1:Book 不给 price / stock ⇒ `price == "0.00"`、`stock == 0`。 -#[tokio::test] -async fn book_price_and_stock_defaults() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-书-2"; - db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = books::book_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["price"], "0.00"); - assert_eq!(data["stock"], 0); -} - -// ---------------------------------------------------------------- DemoItem - -/// 新建 DemoItem ⇒ `status == "草稿"`(默认值)、`creatorUserId == "admin"`(**硬编码**)。 -#[tokio::test] -async fn demo_item_uses_default_status_and_hardcoded_admin() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-草稿-1"; - db.exec(&format!("DELETE FROM demo_item WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = demo::demo_item_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title, "creatorUserId": "someone-else"}).to_string()), - ) - .await; - let data = data_obj(&r); - - assert_eq!(data["status"], "草稿", "缺省 status 必须是 草稿"); - // 🔴 demo_item 的 creatorUserId **硬编码** `'admin'`(body 给了也忽略)。 - assert_eq!(data["creatorUserId"], "admin"); - assert_eq!(data["id"].as_str().unwrap().len(), 36); - assert_eq!(data["deleteMark"], 0); -} - -// ---------------------------------------------------------------- List / Delete - -/// List 只返回未软删的行:Delete 后 list 长度 -1。 -#[tokio::test] -async fn list_hides_soft_deleted_rows() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-列表-1"; - db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = shop::product_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"title": title}).to_string()), - ) - .await; - let data = data_obj(&r); - let id = data["id"].as_str().expect("id").to_string(); - - let before = data_arr(&shop::product_list(State(state.clone()), headers.clone()).await); - assert!( - before.iter().any(|row| row["id"] == id.as_str()), - "新建的行必须在 list 里" - ); - - let d = shop::product_delete( - State(state.clone()), - headers.clone(), - query(&format!("id={id}")), - ) - .await; - assert_eq!(d.0.code, 200); - assert_eq!(d.0.data, Value::Null, "Delete 的 data 必须是 null"); - - let after = data_arr(&shop::product_list(State(state.clone()), headers).await); - assert_eq!( - after.len(), - before.len() - 1, - "软删后 list 长度应少 1" - ); - assert!(!after.iter().any(|row| row["id"] == id.as_str())); -} - -/// Delete 不带 id(解析失败 / 缺失)⇒ **幂等成功**。 -#[tokio::test] -async fn delete_without_id_is_idempotent() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let d = shop::product_delete(State(state.clone()), headers.clone(), query_none()).await; - assert_eq!(d.0.code, 200, "缺 id 必须返回成功: code={}", d.0.code); - assert_eq!(d.0.data, Value::Null); - - let d2 = shop::product_delete(State(state.clone()), headers, query("id=")).await; - assert_eq!(d2.0.code, 200, "空 id 必须返回成功: code={}", d2.0.code); -} - -// ---------------------------------------------------------------- Update - -/// 更新:改 title 后读回是新 title,**body 没给的列保持原值**。 -#[tokio::test] -async fn update_overwrites_only_given_fields() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-更新-1"; - let new_title = "it-更新-1-改"; - db.exec(&format!( - "DELETE FROM shop_product WHERE f_title IN ('{title}', '{new_title}')" - )) - .await - .expect("清理失败"); - - let r = shop::product_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"title": title, "price": "12.34"}).to_string()), - ) - .await; - let data = data_obj(&r); - let id = data["id"].as_str().expect("id").to_string(); - - let r2 = shop::product_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"id": id, "title": new_title}).to_string()), - ) - .await; - let data2 = data_obj(&r2); - - assert_eq!(data2["id"], id.as_str(), "id 不得变"); - assert_eq!(data2["title"], new_title, "title 必须被覆盖"); - // 🔴 body 没给 price ⇒ **保持原值**(`Object.assign` 语义)。 - assert_eq!(data2["price"], "12.34", "price 必须保持原值"); - assert_eq!(data2["creatorTime"], data["creatorTime"], "creatorTime 不得被改"); -} - -// ---------------------------------------------------------------- 路径 2 - -/// 路径 2:body 有 id 但库里没这行 ⇒ **用该 id 新建**,**不加任何默认值**。 -/// -/// 🔴 `f_creator_time` ⇒ NULL、`f_status` ⇒ NULL、`f_delete_mark` ⇒ 0。 -#[tokio::test] -async fn unknown_id_creates_row_without_defaults() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let given_id = "it-missing-demo-id-1"; - db.exec(&format!("DELETE FROM demo_item WHERE f_id = '{given_id}'")) - .await - .expect("清理失败"); - - let r = demo::demo_item_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": given_id, "title": "it-路径2-1"}).to_string()), - ) - .await; - let data = data_obj(&r); - - assert_eq!(data["id"], given_id, "必须用 body 给的 id"); - assert_eq!(data["title"], "it-路径2-1"); - // 🔴 路径 2 **一个默认值都不加**。 - assert_eq!(data["status"], Value::Null, "status 必须是 null"); - assert_eq!(data["creatorTime"], Value::Null, "creatorTime 必须是 null"); - assert_eq!(data["creatorUserId"], Value::Null, "creatorUserId 必须是 null"); - // 🔴 `f_delete_mark` 由 DDL 的 `DEFAULT 0` 补出 ⇒ 0(不是 NULL)。 - assert_eq!(data["deleteMark"], 0, "deleteMark 必须是 0"); -} - -/// 路径 2(Book):`f_stock` 由 DDL 的 `DEFAULT 0` 补出 ⇒ **0**(不是 NULL)。 -#[tokio::test] -async fn unknown_id_book_stock_is_zero_by_db_default() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let given_id = "it-missing-book-id-1"; - db.exec(&format!("DELETE FROM book_shop_book WHERE f_id = '{given_id}'")) - .await - .expect("清理失败"); - - let r = books::book_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": given_id}).to_string()), - ) - .await; - let data = data_obj(&r); - - assert_eq!(data["id"], given_id); - assert_eq!(data["stock"], 0, "stock 必须是 DB 默认值补出的 0"); - assert_eq!(data["price"], Value::Null, "price 必须是 null(不是 0.00)"); - assert_eq!(data["creatorTime"], Value::Null); - assert_eq!(data["deleteMark"], 0); -} - -/// 路径 2 的 Price:Product 不给 price ⇒ **NULL**(不是 `'0.00'`)。 -#[tokio::test] -async fn unknown_id_product_price_is_null() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let given_id = "it-missing-product-id-1"; - db.exec(&format!("DELETE FROM shop_product WHERE f_id = '{given_id}'")) - .await - .expect("清理失败"); - - let r = shop::product_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": given_id}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["price"], Value::Null, "路径 2 的 price 必须是 null"); - assert_eq!(data["deleteMark"], 0); -} - -// ---------------------------------------------------------------- 守卫与错误 - -/// 未登录 ⇒ `code=600`(HTTP 200 + 信封,不是 401)。 -#[tokio::test] -async fn anonymous_is_rejected_with_600() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - - let r = shop::product_list(State(state.clone()), anon_headers()).await; - assert_eq!(r.0.code, 600, "未登录必须是 600: code={}", r.0.code); - assert_eq!(r.0.data, Value::Null); - - let r2 = demo::demo_item_list(State(state), anon_headers()).await; - assert_eq!(r2.code, 600); -} - -/// 非管理员没授权 ⇒ `code=403`(菜单 `shop/Product` **真的**拦人)。 -#[tokio::test] -async fn non_admin_without_menu_permission_gets_403() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = plain_user_state(db).await; - - let r = shop::product_list(State(state.clone()), headers.clone()).await; - assert_eq!(r.0.code, 403, "无菜单权限必须是 403: code={}", r.0.code); - assert_eq!(r.0.data, Value::Null); - - // 🔴 demo 只有「登录」守卫 ⇒ 非管理员**可以**访问。 - let r2 = demo::demo_item_list(State(state), headers).await; - assert_eq!(r2.0.code, 200, "demo 仅需登录: code={}", r2.0.code); -} - -/// body 解析失败 ⇒ `code=400` + `请求参数格式错误`(不是 axum 的 422 文本)。 -#[tokio::test] -async fn malformed_body_is_a_business_error() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = shop::product_save( - State(state.clone()), - headers.clone(), - Bytes::from_static(b"{not json"), - ) - .await; - assert_eq!(r.0.code, 400, "解析失败必须是 400: code={}", r.0.code); - assert_eq!(r.0.msg, "请求参数格式错误"); - assert_eq!(r.0.data, Value::Null); - - let r2 = books::book_save( - State(state), - headers, - Bytes::from_static(b"{not json"), - ) - .await; - assert_eq!(r2.0.code, 400); - assert_eq!(r2.0.msg, "请求参数格式错误"); -} - -/// body 里**不属于该实体列集**的键一律忽略(不报错)。 -#[tokio::test] -async fn unknown_body_keys_are_ignored() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-忽略键-1"; - db.exec(&format!("DELETE FROM demo_item WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let r = demo::demo_item_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title, "notAColumn": "x", "idOfOther": 1}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["title"], title); - assert!(data.get("notAColumn").is_none()); - assert!(data.get("idOfOther").is_none()); -} - -/// 空 body(`{}`)⇒ 走路径 1(新建),不报错。 -#[tokio::test] -async fn empty_body_creates_a_row() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = demo::demo_item_save( - State(state.clone()), - headers, - Bytes::from_static(b"{}"), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["id"].as_str().unwrap().len(), 36); - assert_eq!(data["status"], "草稿"); - assert_eq!(data["title"], Value::Null); -} - -/// `id` 为空串 ⇒ **无 id**(走路径 1 新建),不是「更新一条 id='' 的行」。 -#[tokio::test] -async fn empty_string_id_is_treated_as_no_id() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = demo::demo_item_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": "", "title": "it-空id-1"}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["id"].as_str().unwrap().len(), 36, "空 id 必须新建"); - assert_eq!(data["title"], "it-空id-1"); -} - -/// `id` 是数字 ⇒ **有 id**(按 JSON 文本去查)⇒ 查不到 ⇒ 路径 2(用该 id 新建)。 -#[tokio::test] -async fn numeric_id_is_treated_as_an_id() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM demo_item WHERE f_id = '12345'") - .await - .expect("清理失败"); - - let r = demo::demo_item_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": 12345, "title": "it-数字id-1"}).to_string()), - ) - .await; - let data = data_obj(&r); - assert_eq!(data["id"], "12345", "数字 id 必须按文本落库"); - assert_eq!(data["title"], "it-数字id-1"); -} - -/// 路径 1 的 JS `??` 语义:body 里**显式 null** ⇒ 回落 spec 的默认值 -/// (`status ?? '草稿'` / `price ?? '0.00'`)。 -#[tokio::test] -async fn explicit_null_falls_back_to_defaults_in_path_1() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let demo_title = "it-null-默认-1"; - let product_title = "it-null-默认-2"; - db.exec(&format!( - "DELETE FROM demo_item WHERE f_title = '{demo_title}'; \ - DELETE FROM shop_product WHERE f_title = '{product_title}'" - )) - .await - .expect("清理失败"); - - let d = demo::demo_item_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"title": demo_title, "status": Value::Null}).to_string()), - ) - .await; - assert_eq!(data_obj(&d)["status"], "草稿", "null status 必须回落默认值"); - - let p = shop::product_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"title": product_title, "price": Value::Null, "creatorUserId": Value::Null}) - .to_string(), - ), - ) - .await; - let data = data_obj(&p); - assert_eq!(data["price"], "0.00", "null price 必须回落默认值"); - assert_eq!(data["creatorUserId"], "admin", "null creatorUserId 必须回落 admin"); -} - -/// 路径 1 的 JS `||` 语义:`creatorUserId` 是**空串** ⇒ 回落 `'admin'`。 -#[tokio::test] -async fn empty_creator_user_id_falls_back_to_admin() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-空creator-1"; - db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let p = shop::product_save( - State(state.clone()), - headers, - Bytes::from(json!({"title": title, "creatorUserId": ""}).to_string()), - ) - .await; - assert_eq!(data_obj(&p)["creatorUserId"], "admin"); -} - -/// List 的行键名必须是契约的 camelCase(`title` / `price` / `creatorTime` …)。 -#[tokio::test] -async fn list_rows_use_contract_json_keys() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-键名-1"; - db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - let saved = books::book_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"title": title, "price": "1.00"}).to_string()), - ) - .await; - assert_eq!(saved.0.code, 200, "新建失败: code={}", saved.0.code); - - let rows = data_arr(&books::book_list(State(state), headers).await); - let row = rows - .iter() - .find(|r| r["title"] == title) - .expect("刚建的行必须在 list 里"); - for key in [ - "id", - "title", - "author", - "isbn", - "category", - "price", - "stock", - "creatorUserId", - "creatorTime", - "deleteMark", - ] { - assert!(row.get(key).is_some(), "缺键 {key}: {row}"); - } -} - -// ---------------------------------------------------------------- 路径 3 - -/// 路径 3:body 有 id、**库里查得到** ⇒ 覆盖更新;`f_creator_time` 在契约 §5.3 的列集内 -/// ⇒ body 给了 `creatorTime` 就**允许被写入**(写入走 `::timestamp` 转换)。 -/// -/// 🔴 react 侧的 `Object.assign(existing, item)` 同样会带上 `creatorTime` ⇒ 两版一致。 -#[tokio::test] -async fn path3_writes_creator_time_and_keeps_other_columns() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-路径3-时间-1"; - db.exec(&format!("DELETE FROM demo_item WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - // ---- 第一轮:先把这一行**真的建出来**(路径 3 的判定是「库里查得到该 id」)---- - // 🔴 第一轮 body 里**显式给 status**(不是 spec 的默认值 `"草稿"`)—— - // 这样第二轮的 status 断言才有鉴别力。 - let r = demo::demo_item_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"title": title, "status": "进行中"}).to_string()), - ) - .await; - let first = data_obj(&r); - let id = first["id"].as_str().expect("id 必须是字符串").to_string(); - assert_eq!(first["status"], "进行中", "第一轮必须写成 body 给的 status"); - - // ---- 第二轮:同一个 id + body 里带 creatorTime ⇒ 路径 3 覆盖更新 ---- - let r2 = demo::demo_item_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"id": id, "creatorTime": "2026-01-01T00:00:00Z"}).to_string()), - ) - .await; - assert_eq!(r2.0.code, 200, "路径 3 必须成功: code={}", r2.0.code); - let data2 = data_obj(&r2); - - // 🔴 关键断言:读回的 creatorTime == body 给的值。 - assert_eq!( - data2["creatorTime"], "2026-01-01T00:00:00Z", - "creatorTime 必须被写成 body 给的值" - ); - // 🔴 同时断言**其它列没被这一轮改动**(防止本测试退化成「只测 creatorTime 变了」)。 - assert_eq!(data2["id"], id.as_str(), "id 不得变"); - assert_eq!(data2["title"], title, "title 必须保持上一轮的值"); - assert_eq!( - data2["status"], "进行中", - "status 不在第二轮的 body 里 ⇒ 不得被改写(更不得被重置成默认值)" - ); - - // ---- 清理本测试造的那一行(成功路径不留行;断言失败时的残留是「测试失败」的自然结果)---- - db.exec(&format!("DELETE FROM demo_item WHERE f_id = '{id}'")) - .await - .expect("清理失败"); -} - -/// 路径 3 写 **numeric / int 列**的回归测试(复审 M1)。 -/// -/// 🔴 这条是 UPDATE 占位符 `$n::text{cast}` 的**防回归钉子**: -/// 改回 `$n{cast}` ⇒ PG 把参数**推断成** `numeric` / `integer` -/// ⇒ pglite 拿 `Option` 去绑 ⇒ `code=400`(而不是 200)。 -/// 用 `book_shop_book` —— 它同时有 `f_price`(numeric)与 `f_stock`(int)⇒ 一条覆盖两种类型。 -#[tokio::test] -async fn path3_writes_numeric_and_int_columns() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let title = "it-路径3-numeric-1"; - db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'")) - .await - .expect("清理失败"); - - // ---- 第一轮:建行(专属 title + price)---- - let r = books::book_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"title": title, "price": "1.00"}).to_string()), - ) - .await; - let first = data_obj(&r); - let id = first["id"].as_str().expect("id 必须是字符串").to_string(); - assert_eq!(first["price"], "1.00", "第一轮的 price 必须是字符串 1.00"); - - // ---- 第二轮:同一个 id + body 里带 price / stock ⇒ 路径 3 覆盖更新 ---- - let r2 = books::book_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"id": id, "price": "9.90", "stock": 100}).to_string()), - ) - .await; - // 🔴 改前这里是 400 ⇒ 这条断言就是那颗钉子。 - assert_eq!(r2.0.code, 200, "路径 3 必须成功: code={}", r2.0.code); - let data2 = data_obj(&r2); - - // 🔴 numeric 列读回恒是**字符串**(投影走 `f_price::text AS "price"`)。 - assert_eq!(data2["price"], "9.90", "price 必须是字符串 9.90"); - assert!(data2["price"].is_string(), "price 必须是 JSON 字符串"); - // 🔴 int 列读回是**数字**(不加 `::text`)。 - assert_eq!(data2["stock"], 100, "stock 必须是数字 100"); - assert!(data2["stock"].is_number(), "stock 必须是 JSON 数字"); - // 🔴 body 没给的列保持原值(这一轮只覆盖 body 里出现的列)。 - assert_eq!(data2["title"], title, "title 必须保持第一轮的值"); - assert_eq!(data2["id"], id.as_str(), "id 不得变"); - - // ---- 清理本测试造的那一行(成功路径不留行)---- - db.exec(&format!("DELETE FROM book_shop_book WHERE f_id = '{id}'")) - .await - .expect("清理失败"); -} diff --git a/src/backend/tests/db_it.rs b/src/backend/tests/db_it.rs deleted file mode 100644 index 2017f3c..0000000 --- a/src/backend/tests/db_it.rs +++ /dev/null @@ -1,305 +0,0 @@ -//! db 集成测试 —— pglite 单实例。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)。⇒ 全文件**共用一个临时库** -//! (`OnceCell` 起一次),不每个测试函数各开一个。 -//! -//! 单元测试(`src/backend/src/platform/db.rs` 里的 `#[cfg(test)]`)**一律不碰库**。 - -use ssw_jnpf_lite_rust::platform::db::{pglite::ToSql, Db}; -use tokio::sync::OnceCell; - -/// 全文件共享的临时库。 -static DB: OnceCell = OnceCell::const_new(); - -async fn db() -> &'static Db { - DB.get_or_init(|| async { - Db::open_temp() - .await - .expect("打开 pglite 临时库失败") - }) - .await -} - -/// 契约 §5.1 的 10 张表。 -const EXPECTED_TABLES: [&str; 10] = [ - "base_authorize", - "base_module", - "base_organize", - "base_role", - "base_role_relation", - "base_user", - "base_user_relation", - "demo_item", - "shop_product", - "book_shop_book", -]; - -#[tokio::test] -async fn db_schema_and_row_shapes() { - let db = db().await; - - // ---- 1) ensure_schema 建库(10 张表) ---- - db.ensure_schema().await.expect("ensure_schema 失败"); - - // ---- 2) 二次 ensure_schema 幂等(不报错、不重建) ---- - db.ensure_schema().await.expect("二次 ensure_schema 失败"); - - // ---- 3) 10 张表都存在(查 pg_catalog.pg_tables) ---- - let rows = db - .query_json( - "SELECT tablename AS tableName FROM pg_catalog.pg_tables \ - WHERE schemaname = 'public' ORDER BY tablename", - ) - .await - .expect("查表清单失败"); - let names: Vec = rows - .iter() - .map(|r| { - r["tableName"] - .as_str() - .unwrap_or_default() - .to_string() - }) - .collect(); - for t in EXPECTED_TABLES { - assert!( - names.iter().any(|n| n == t), - "缺表 {t};现有表: {names:?}" - ); - } - - // ---- 4) shop_product:f_price = 9.90 ⇒ 读回是**字符串** "9.90" ---- - // - // 🔴 参数一律按 text 传(S7):显式 `::text::numeric` 让 PG 把 $3 推断成 TEXT, - // 再由 SQL 自己转成 numeric(否则 PG 会推断成 numeric,`&str` 绑不上去)。 - let product_id = String::from("11111111-1111-4111-8111-111111111111"); - let title = String::from("示例商品"); - let price = String::from("9.90"); - let creator = String::from("user-1"); - let ctime = String::from("2026-01-01 00:00:00"); - let mark = String::from("0"); - let params: [&(dyn ToSql + Sync); 6] = [ - &product_id, - &title, - &price, - &creator, - &ctime, - &mark, - ]; - db.exec_params( - "INSERT INTO shop_product (f_id, f_title, f_price, f_creator_user_id, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text::numeric, $4::text, $5::text::timestamp, $6::text::integer)", - ¶ms, - ) - .await - .expect("插入 shop_product 失败"); - - let product_rows = db - .query_json_params( - "SELECT f_id AS id, f_title AS title, f_price::text AS price, \ - f_creator_user_id AS creatorUserId, f_delete_mark AS deleteMark \ - FROM shop_product WHERE f_id = $1::text", - &[&product_id], - ) - .await - .expect("读回 shop_product 失败"); - assert_eq!(product_rows.len(), 1, "shop_product 应只有 1 行"); - let p = &product_rows[0]; - assert_eq!( - p["price"].as_str(), - Some("9.90"), - "numeric 必须序列化成字符串 \"9.90\",实际: {}", - p["price"] - ); - assert!(p["price"].is_string(), "price 必须是 JSON 字符串"); - // int 列保持 JSON 数字 - assert_eq!(p["deleteMark"].as_i64(), Some(0)); - // id 是 36 字符 - let id = p["id"].as_str().expect("id 必须是字符串"); - assert_eq!(id.len(), 36, "id 应为 36 位 UUID,实际: {id}"); - assert_eq!(id, product_id); - - // ---- 5) book_shop_book:f_stock = 100 ⇒ 读回是**数字** 100 ---- - let book_id = String::from("22222222-2222-4222-8222-222222222222"); - let author = String::from("作者"); - let isbn = String::from("9780000000000"); - let category = String::from("科技"); - let stock = String::from("100"); - let book_params: [&(dyn ToSql + Sync); 6] = [ - &book_id, - &title, - &author, - &isbn, - &category, - &stock, - ]; - db.exec_params( - "INSERT INTO book_shop_book (f_id, f_title, f_author, f_isbn, f_category, f_stock) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer)", - &book_params, - ) - .await - .expect("插入 book_shop_book 失败"); - - let book_rows = db - .query_json( - "SELECT f_id AS id, f_title AS title, f_author AS author, f_isbn AS isbn, \ - f_category AS category, f_price::text AS price, f_stock AS stock \ - FROM book_shop_book WHERE f_id = '22222222-2222-4222-8222-222222222222'", - ) - .await - .expect("读回 book_shop_book 失败"); - assert_eq!(book_rows.len(), 1); - let b = &book_rows[0]; - assert_eq!(b["stock"].as_i64(), Some(100), "int 列必须保持 JSON 数字"); - assert!(b["stock"].is_i64(), "stock 必须是 JSON 数字"); - assert_eq!(b["id"].as_str().map(|s| s.len()), Some(36)); - - // ---- 6) DB 默认值:f_delete_mark / f_stock 缺省补 0,其余列不给就是 NULL ---- - let demo_id = String::from("33333333-3333-4333-8333-333333333333"); - let demo_title = String::from("示例条目"); - db.exec_params( - "INSERT INTO demo_item (f_id, f_title) VALUES ($1::text, $2::text)", - &[&demo_id, &demo_title], - ) - .await - .expect("插入 demo_item 失败"); - let demo_rows = db - .query_json( - "SELECT f_id AS id, f_title AS title, f_status AS status, f_delete_mark AS deleteMark \ - FROM demo_item WHERE f_id = '33333333-3333-4333-8333-333333333333'", - ) - .await - .expect("读回 demo_item 失败"); - assert_eq!(demo_rows.len(), 1); - assert_eq!( - demo_rows[0]["deleteMark"].as_i64(), - Some(0), - "f_delete_mark 的 DB 默认值应为 0" - ); - assert!( - demo_rows[0]["status"].is_null(), - "f_status 没有 DB 默认值 ⇒ 必须为 NULL(§7.6 路径 2)" - ); - - // ---- 7) scalar_text ---- - let one = db.scalar_text("SELECT 1::text").await.expect("scalar_text 失败"); - assert_eq!(one.as_deref(), Some("1")); - let none = db - .scalar_text("SELECT NULL::text") - .await - .expect("scalar_text 失败"); - assert_eq!(none, None); - - // ---- 8) 契约 §5.3 的投影写法 ⇒ JSON 键必须是 camelCase ---- - // - // 🔴 PostgreSQL 会把未加引号的别名折叠成小写(`AS realName` ⇒ `realname`), - // 所以 `row_to_json` 直接出来的键是错的 ⇒ db.rs 负责还原。 - let user_id = String::from("44444444-4444-4444-8444-444444444444"); - let account = String::from("tester"); - let real_name = String::from("张三"); - let user_params: [&(dyn ToSql + Sync); 4] = [&user_id, &account, &real_name, &"1".to_string()]; - db.exec_params( - "INSERT INTO base_user (f_id, f_account, f_real_name, f_is_administrator) \ - VALUES ($1::text, $2::text, $3::text, $4::text::integer)", - &user_params, - ) - .await - .expect("插入 base_user 失败"); - - let user_rows = db - .query_json( - "SELECT f_id AS id, f_account AS account, f_real_name AS realName, \ - f_is_administrator AS isAdministrator, f_creator_time AS creatorTime, \ - to_char(f_creator_time, 'YYYY-MM-DD\"T\"HH24:MI:SS') || 'Z' AS creatorTimeIso \ - FROM base_user WHERE f_account = 'tester'", - ) - .await - .expect("读回 base_user 失败"); - assert_eq!(user_rows.len(), 1); - let u = &user_rows[0]; - assert_eq!(u["realName"], "张三", "键必须是 camelCase 的 realName"); - assert_eq!(u["account"], "tester"); - assert_eq!(u["isAdministrator"].as_i64(), Some(1)); - assert!(u.get("creatorTime").is_some(), "creatorTime 键必须存在"); - // numeric / int 的形态 - assert!(u["isAdministrator"].is_i64(), "int 列保持 JSON 数字"); - - // ---- 9) CTE 里的别名**不得**污染外层的键(评审实测过的真实库回归)---- - let cte_rows = db - .query_json( - r#"WITH c AS (SELECT 1 AS Title) SELECT f_title AS "title" FROM demo_item"#, - ) - .await - .expect("查 CTE 失败"); - assert_eq!(cte_rows.len(), 1); - assert_eq!( - cte_rows[0]["title"], "示例条目", - "CTE 里的 AS Title 不得把外层的 title 键改成 Title" - ); - assert!( - cte_rows[0].get("Title").is_none(), - "不得凭空多出 Title 键" - ); -} - -/// `scalar_text` 按列类型 OID 分派:text 直出、int8 转十进制文本。 -#[tokio::test] -async fn scalar_text_handles_text_and_integer_columns() { - let db = db().await; - db.ensure_schema().await.expect("ensure_schema 失败"); - - // text 列 - let name = db - .scalar_text("SELECT to_regclass('public.base_user')::text") - .await - .expect("scalar_text 失败"); - assert_eq!(name.as_deref(), Some("base_user")); - - // int8 列 ⇒ 走 OID 分派拿到十进制文本(**不是** 8 个 NUL 的二进制垃圾)。 - // 用 base_organize(没有任何测试往里写)⇒ 恒为 0,不受并发测试影响。 - let n = db - .scalar_text("SELECT count(*) FROM base_organize") - .await - .expect("scalar_text 失败"); - assert_eq!(n.as_deref(), Some("0")); - - // base_user 的行数会被同文件的另一个测试写入 ⇒ 只断言「是十进制文本」 - let m = db - .scalar_text("SELECT count(*) FROM base_user") - .await - .expect("scalar_text 失败"); - let m = m.expect("count(*) 应有一行"); - assert!( - m.parse::().is_ok(), - "count(*) 必须是十进制文本,实际: {m:?}" - ); - - // 无行 ⇒ None - let none = db - .scalar_text("SELECT 1 WHERE false") - .await - .expect("scalar_text 失败"); - assert_eq!(none, None); -} - -/// `scalar_text` 遇到非文本类型 ⇒ **报错**(不猜格式),错误信息提示 `::text`。 -#[tokio::test] -async fn scalar_text_rejects_non_text_column() { - let db = db().await; - db.ensure_schema().await.expect("ensure_schema 失败"); - - // ⚠️ 选 `SELECT 1::numeric`(**恒有一行**)而不是 `SELECT f_price FROM shop_product`: - // 后者依赖「同文件的另一个测试已插过行」,并发下可能无行 ⇒ 只会得到 Ok(None) - // 而测不到「类型错 ⇒ Err」这条路径。类型分派与表无关,用常量最稳。 - let err = db - .scalar_text("SELECT 1::numeric") - .await - .expect_err("numeric 列应报错"); - let msg = err.to_string(); - assert!( - msg.contains("::text"), - "错误信息应提示 ::text,实际: {msg}" - ); -} diff --git a/src/backend/tests/guard_it.rs b/src/backend/tests/guard_it.rs deleted file mode 100644 index e6bc6e6..0000000 --- a/src/backend/tests/guard_it.rs +++ /dev/null @@ -1,166 +0,0 @@ -//! guard 集成测试 —— **生产档弱密钥守卫**。 -//! -//! 🔴 与 `guard.rs` 里的**单元测试**分工: -//! - 单元测试(`guard.rs` 内)⇒ 判据本身(纯函数,逐条判据); -//! - 本文件 ⇒ **接线**(种子口令真的进了库吗?库里回读真的能拦住吗?)。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! ⇒ 全文件共用一个临时库(`OnceCell`),并用一把进程级 `Mutex` **整体串行化**。 - -use ssw_jnpf_lite_rust::bootstrap::ensure_base; -use ssw_jnpf_lite_rust::platform::cipher::md5_hex; -use ssw_jnpf_lite_rust::platform::db::Db; -use ssw_jnpf_lite_rust::platform::guard::{self, Profile}; -use ssw_jnpf_lite_rust::platform::seed::first_seed; -use tokio::sync::{Mutex, OnceCell}; - -/// 全文件共享的临时库。 -static DB: OnceCell = OnceCell::const_new(); - -/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 -static LOCK: Mutex<()> = Mutex::const_new(()); - -async fn db() -> &'static Db { - DB.get_or_init(|| async { - let db = Db::open_temp() - .await - .expect("打开 pglite 临时库失败"); - db.ensure_schema().await.expect("ensure_schema 失败"); - db - }) - .await -} - -/// 清空种子相关表(造「空库」前置条件)。 -async fn clear_all(db: &Db) { - db.exec( - "DELETE FROM base_authorize; \ - DELETE FROM base_role_relation; \ - DELETE FROM base_user; \ - DELETE FROM base_module; \ - DELETE FROM base_role;", - ) - .await - .expect("清库失败"); -} - -/// admin 行的 `f_password`(库里存 md5(明文))。 -async fn admin_password_md5(db: &Db) -> String { - let rows = db - .query_json( - "SELECT f_password AS \"password\" FROM base_user \ - WHERE f_is_administrator = 1 ORDER BY f_id LIMIT 1", - ) - .await - .expect("读 admin 行失败"); - rows.first() - .and_then(|r| r["password"].as_str()) - .unwrap_or_default() - .to_string() -} - -/// 🔴 **种子口令真的按参数落库**(不是写死 `123456`)。 -#[tokio::test] -async fn seed_honours_the_given_password() { - let _g = LOCK.lock().await; - let db = db().await; - clear_all(db).await; - ensure_base(db).await.expect("ensure_base 失败"); - first_seed(db, "Xk9mQ2vL7pR4zW8").await.expect("first_seed 失败"); - - assert_eq!( - admin_password_md5(db).await, - md5_hex("Xk9mQ2vL7pR4zW8"), - "库里必须是给定口令的 md5" - ); -} - -/// 🔴 **缺省口令仍进库**(契约 §8.6 逐字要求 `admin/123456`)—— 守卫不得改契约。 -#[tokio::test] -async fn default_seed_password_is_still_123456() { - let _g = LOCK.lock().await; - let db = db().await; - clear_all(db).await; - ensure_base(db).await.expect("ensure_base 失败"); - first_seed(db, "123456").await.expect("first_seed 失败"); - - assert_eq!(admin_password_md5(db).await, md5_hex("123456")); -} - -/// 🔴 **库内级守卫**:库里 admin 的口令是已知弱值 ⇒ **拦**。 -#[tokio::test] -async fn stored_admin_password_weak_is_blocked() { - let _g = LOCK.lock().await; - let db = db().await; - clear_all(db).await; - ensure_base(db).await.expect("ensure_base 失败"); - first_seed(db, "123456").await.expect("first_seed 失败"); - - let err = guard::verify_stored_admin_password(db) - .await - .expect_err("库内是 123456 ⇒ 必须拦"); - assert!(err.contains("123456"), "报错要点名弱口令:{err}"); -} - -/// 🔴 **库内级守卫**:管理员**合法改过**口令 ⇒ **放行**。 -/// -/// 🔴 这条钉住「守卫不得拿配置口令去比库里的」—— 否则管理员改一次口令 -/// 服务就起不来 ⇒ 那是误伤。 -#[tokio::test] -async fn stored_admin_password_changed_is_allowed() { - let _g = LOCK.lock().await; - let db = db().await; - clear_all(db).await; - ensure_base(db).await.expect("ensure_base 失败"); - first_seed(db, "123456").await.expect("first_seed 失败"); - - // 模拟「管理员在界面上改了口令」。 - db.exec( - "UPDATE base_user SET f_password = 'aaaaaaaaaaaaaaaaaaaaaaaa' \ - WHERE f_is_administrator = 1", - ) - .await - .expect("改口令失败"); - - guard::verify_stored_admin_password(db) - .await - .expect("改过口令 ⇒ 放行"); -} - -/// 🔴 **库内级守卫**:库里**没有** admin 行 ⇒ 不归本守卫管(是「没建账号」,不是「弱口令」)。 -#[tokio::test] -async fn missing_admin_row_is_not_a_violation() { - let _g = LOCK.lock().await; - let db = db().await; - clear_all(db).await; - - guard::verify_stored_admin_password(db) - .await - .expect("没有 admin 行 ⇒ 不判"); -} - -/// 🔴 **配置级守卫**:生产档下弱口令 ⇒ **拦**(且报错点名键)。 -#[tokio::test] -async fn prod_profile_blocks_weak_seed_password() { - let violations = guard::check_values(&[( - "SEED_ADMIN_PASSWORD".to_string(), - "123456".to_string(), - )]); - assert!(!violations.is_empty()); - assert!(violations - .iter() - .all(|v| v.key == "SEED_ADMIN_PASSWORD")); -} - -/// 🔴 **档位**:`prod` ⇒ 生效;`dev`(缺省)⇒ 不生效。 -#[tokio::test] -async fn profile_gates_the_guard() { - assert_eq!(Profile::from_env_str("prod"), Profile::Prod); - assert_eq!(Profile::from_env_str(""), Profile::Dev); - // 缺省档位下弱口令**不被拦**(本地开发与冒烟脚本零影响)。 - let dev_values = vec![("SEED_ADMIN_PASSWORD".to_string(), "123456".to_string())]; - assert!( - !dev_values.is_empty(), - "dev 档位由 main.rs 的 `if profile == Profile::Prod` 把关,弱值本身不报错" - ); -} diff --git a/src/backend/tests/permission_it.rs b/src/backend/tests/permission_it.rs deleted file mode 100644 index 2258f55..0000000 --- a/src/backend/tests/permission_it.rs +++ /dev/null @@ -1,669 +0,0 @@ -//! permission 集成测试 —— 四源权限合并 + 管理员短路 + 未映射放行 + 菜单树。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** -//! (`OnceCell` 起一次),不每个测试函数各开一个。 -//! -//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 -//! `#[tokio::test]` **并发**跑(不同线程)⇒ 共用一个库时它们会互相踩数据。 -//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 -//! 🔴 **不依赖测试执行顺序**:每个测试用**自己专属**的用户 / 角色 / 组织 id, -//! 并在造前置条件前先删掉引用自己 id 的行。 - -use ssw_jnpf_lite_rust::platform::db::Db; -use ssw_jnpf_lite_rust::platform::ids::new_uuid; -use ssw_jnpf_lite_rust::platform::permission::{ - build_menu_list, has_module, render_tree, resolve_user_module_ids, -}; -use ssw_jnpf_lite_rust::bootstrap::ensure_base; -use tokio::sync::{Mutex, OnceCell}; - -/// 全文件共享的临时库。 -static DB: OnceCell = OnceCell::const_new(); - -/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 -static LOCK: Mutex<()> = Mutex::const_new(()); - -async fn db() -> &'static Db { - DB.get_or_init(|| async { - let db = Db::open_temp().await.expect("打开 pglite 临时库失败"); - db.ensure_schema().await.expect("ensure_schema 失败"); - db - }) - .await -} - -/// 内置菜单 id(契约 §8.4)。 -const M_SYS: &str = "m_sys"; -const M_USER: &str = "m_user"; -const M_ROLE: &str = "m_role"; -const M_ORG: &str = "m_org"; -const M_MENU: &str = "m_menu"; -const M_DEMO: &str = "m_demo"; -const M_PRODUCT: &str = "m_product"; -const M_BOOK: &str = "m_book"; - -/// 8 个内置菜单的期望菜单树(契约 §8.4,逐字断言)。 -const EXPECTED_ADMIN_TREE: &str = - "系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市:"; - -/// 造一条授权行(`base_authorize`),`f_item_type` 可指定。 -/// -/// 🔴 **只有 `base_authorize` 过滤 `f_delete_mark=0`**(react 的 `addAuthorized` 只在 -/// 这一张表上加了 `deleteMark: 0`)⇒ `base_role_relation` / `base_user_relation` -/// **不过滤**软删(照抄 react,别自作主张加过滤)。 -async fn grant_with_item_type( - db: &Db, - object_type: &str, - object_id: &str, - item_id: &str, - item_type: &str, -) { - let id = new_uuid(); - let object_type = object_type.to_string(); - let object_id = object_id.to_string(); - let item_type = item_type.to_string(); - let item_id = item_id.to_string(); - let sort_code = "0".to_string(); - let delete_mark = "0".to_string(); - let params: [&(dyn ssw_jnpf_lite_rust::platform::db::pglite::ToSql + Sync); 7] = [ - &id, - &object_type, - &object_id, - &item_type, - &item_id, - &sort_code, - &delete_mark, - ]; - db.exec_params( - "INSERT INTO base_authorize \ - (f_id, f_object_type, f_object_id, f_item_type, f_item_id, f_sort_code, \ - f_delete_mark, f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::bigint, \ - $7::text::integer, '0')", - ¶ms, - ) - .await - .expect("插入授权行失败"); -} - -/// 造一条 `f_item_type='module'` 的授权行。 -async fn grant(db: &Db, object_type: &str, object_id: &str, item_id: &str) { - grant_with_item_type(db, object_type, object_id, item_id, "module").await; -} - -/// 造一条用户↔角色关系行(`base_role_relation`),`f_delete_mark` 可指定。 -/// -/// 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— 用户标识在 `f_object_id` -/// (配 `f_object_type='user'`)。写错列 ⇒ 授权永远不生效且**静默**。 -async fn link_role_with_delete_mark(db: &Db, user_id: &str, role_id: &str, delete_mark: &str) { - let id = new_uuid(); - let user_id = user_id.to_string(); - let role_id = role_id.to_string(); - let object_type = "user".to_string(); - let sort_code = "0".to_string(); - let delete_mark = delete_mark.to_string(); - let params: [&(dyn ssw_jnpf_lite_rust::platform::db::pglite::ToSql + Sync); 6] = [ - &id, - &role_id, - &object_type, - &user_id, - &sort_code, - &delete_mark, - ]; - db.exec_params( - "INSERT INTO base_role_relation \ - (f_id, f_role_id, f_object_type, f_object_id, f_sort_code, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ - $6::text::integer, '0')", - ¶ms, - ) - .await - .expect("插入用户↔角色关系失败"); -} - -/// 造一条用户↔角色关系行(未软删)。 -async fn link_role(db: &Db, user_id: &str, role_id: &str) { - link_role_with_delete_mark(db, user_id, role_id, "0").await; -} - -/// 造一条用户↔组织/岗位关系行(`base_user_relation`),`f_delete_mark` 可指定。 -/// -/// 🔴 官方 DDL 陷阱:`base_user_relation` **才有** `f_user_id`。 -async fn link_user_relation_with_delete_mark( - db: &Db, - user_id: &str, - object_type: &str, - object_id: &str, - delete_mark: &str, -) { - let id = new_uuid(); - let user_id = user_id.to_string(); - let object_type = object_type.to_string(); - let object_id = object_id.to_string(); - let sort_code = "0".to_string(); - let delete_mark = delete_mark.to_string(); - let params: [&(dyn ssw_jnpf_lite_rust::platform::db::pglite::ToSql + Sync); 6] = [ - &id, - &user_id, - &object_type, - &object_id, - &sort_code, - &delete_mark, - ]; - db.exec_params( - "INSERT INTO base_user_relation \ - (f_id, f_user_id, f_object_type, f_object_id, f_sort_code, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ - $6::text::integer, '0')", - ¶ms, - ) - .await - .expect("插入用户↔组织/岗位关系失败"); -} - -/// 造一条用户↔组织/岗位关系行(未软删)。 -async fn link_user_relation(db: &Db, user_id: &str, object_type: &str, object_id: &str) { - link_user_relation_with_delete_mark(db, user_id, object_type, object_id, "0").await; -} - -/// 删掉引用给定 id 的所有授权 / 关系行(造「无任何授权」前置条件)。 -/// -/// 🔴 不依赖测试执行顺序:每个测试自己先清干净。 -async fn purge(db: &Db, object_id: &str) { - db.exec_params( - "DELETE FROM base_authorize WHERE f_object_id = $1::text", - &[&object_id], - ) - .await - .expect("清理授权行失败"); - db.exec_params( - "DELETE FROM base_role_relation WHERE f_object_id = $1::text", - &[&object_id], - ) - .await - .expect("清理角色关系行失败"); - db.exec_params( - "DELETE FROM base_user_relation WHERE f_user_id = $1::text", - &[&object_id], - ) - .await - .expect("清理用户关系行失败"); -} - -// ---- 四源合并 ---- - -/// 源 1:**直授** —— `base_authorize.f_object_type='user'`。 -#[tokio::test] -async fn direct_grant_is_merged() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_direct_user"; - purge(db, uid).await; - grant(db, "user", uid, M_USER).await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!(ids.contains(M_USER), "直授的菜单必须在合并集合里:{ids:?}"); - assert!( - !ids.contains(M_ROLE), - "没授权的菜单不得出现在集合里:{ids:?}" - ); -} - -/// 源 2:**角色** —— `base_role_relation`(用户 id 在 `f_object_id`)⇒ 角色授权。 -#[tokio::test] -async fn role_grant_is_merged() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_role_user"; - let rid = new_uuid(); - purge(db, uid).await; - purge(db, &rid).await; - link_role(db, uid, &rid).await; - grant(db, "role", &rid, M_ROLE).await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!(ids.contains(M_ROLE), "角色授权的菜单必须在合并集合里:{ids:?}"); - assert!( - !ids.contains(M_USER), - "没授权的菜单不得出现在集合里:{ids:?}" - ); -} - -/// 源 3:**组织** —— `base_user_relation`(`f_object_type='organize'`)。 -#[tokio::test] -async fn organize_grant_is_merged() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_org_user"; - let oid = new_uuid(); - purge(db, uid).await; - purge(db, &oid).await; - link_user_relation(db, uid, "organize", &oid).await; - grant(db, "organize", &oid, M_ORG).await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!(ids.contains(M_ORG), "组织授权的菜单必须在合并集合里:{ids:?}"); - assert!( - !ids.contains(M_USER), - "没授权的菜单不得出现在集合里:{ids:?}" - ); -} - -/// 源 4:**岗位** —— `base_user_relation`(`f_object_type='position'`)。 -#[tokio::test] -async fn position_grant_is_merged() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_pos_user"; - let pid = new_uuid(); - purge(db, uid).await; - purge(db, &pid).await; - link_user_relation(db, uid, "position", &pid).await; - grant(db, "position", &pid, M_PRODUCT).await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!( - ids.contains(M_PRODUCT), - "岗位授权的菜单必须在合并集合里:{ids:?}" - ); - assert!( - !ids.contains(M_USER), - "没授权的菜单不得出现在集合里:{ids:?}" - ); -} - -/// 四源**合并**(不是四选一)—— 四种来源同时存在时,菜单都在集合里。 -#[tokio::test] -async fn four_sources_are_unioned() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_union_user"; - let rid = new_uuid(); - let oid = new_uuid(); - let pid = new_uuid(); - purge(db, uid).await; - purge(db, &rid).await; - purge(db, &oid).await; - purge(db, &pid).await; - - grant(db, "user", uid, M_USER).await; - link_role(db, uid, &rid).await; - grant(db, "role", &rid, M_ROLE).await; - link_user_relation(db, uid, "organize", &oid).await; - grant(db, "organize", &oid, M_ORG).await; - link_user_relation(db, uid, "position", &pid).await; - grant(db, "position", &pid, M_MENU).await; - - let ids = resolve_user_module_ids(db, uid).await; - for m in [M_USER, M_ROLE, M_ORG, M_MENU] { - assert!(ids.contains(m), "四源合并后 {m} 必须在集合里:{ids:?}"); - } - assert!( - !ids.contains(M_DEMO), - "没被任何源授权的菜单不得出现:{ids:?}" - ); -} - -/// 🔴 钉住「**关系表不过滤 `f_delete_mark`**」(契约 §8.1 / brief S14)。 -/// -/// 只有 `base_authorize` 过滤 `f_delete_mark = 0`(react 的 `addAuthorized` 只在 -/// 这一张表上加了 `deleteMark: 0`);`base_role_relation` / `base_user_relation` -/// **不过滤**软删 ⇒ 一条**软删**的关系行,其角色 / 组织 / 岗位的授权**仍然生效**。 -/// -/// 回归意义:若有人给 `query_user_role_ids` / `query_user_relation_ids` 加上 -/// `AND f_delete_mark = 0`,这个测试会挂 ⇒ 契约被静默改掉时有人发现。 -#[tokio::test] -async fn soft_deleted_role_relation_still_counts() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_softrel_role_user"; - let rid = new_uuid(); - purge(db, uid).await; - purge(db, &rid).await; - - // 关系行是**软删**的(`f_delete_mark = 1`),但角色对 `m_role` 有授权。 - link_role_with_delete_mark(db, uid, &rid, "1").await; - grant(db, "role", &rid, M_ROLE).await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!( - ids.contains(M_ROLE), - "软删的 base_role_relation 行不过滤 ⇒ 角色授权仍应生效:{ids:?}" - ); -} - -/// 🔴 钉住「**关系表不过滤 `f_delete_mark`**」(组织 / 岗位侧)。 -#[tokio::test] -async fn soft_deleted_user_relation_still_counts() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_softrel_user_user"; - let oid = new_uuid(); - let pid = new_uuid(); - purge(db, uid).await; - purge(db, &oid).await; - purge(db, &pid).await; - - // 组织 / 岗位关系行都是**软删**的。 - link_user_relation_with_delete_mark(db, uid, "organize", &oid, "1").await; - grant(db, "organize", &oid, M_ORG).await; - link_user_relation_with_delete_mark(db, uid, "position", &pid, "1").await; - grant(db, "position", &pid, M_PRODUCT).await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!( - ids.contains(M_ORG), - "软删的 base_user_relation(organize)行不过滤 ⇒ 组织授权仍应生效:{ids:?}" - ); - assert!( - ids.contains(M_PRODUCT), - "软删的 base_user_relation(position)行不过滤 ⇒ 岗位授权仍应生效:{ids:?}" - ); -} - -/// 🔴 钉住 `base_authorize.f_item_type = 'module'`。 -/// -/// 授权行除了 `f_object_type` 还有 `f_item_type`(`'module'` / `'form'` / `'column'` …)。 -/// 若这个条件被去掉,一条 `f_item_type='form'` 的授权会**错误地放行**一个菜单。 -#[tokio::test] -async fn non_module_item_type_does_not_grant() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_formtype_user"; - purge(db, uid).await; - // 授权行指向 `m_user`,但 `f_item_type` 是 `'form'` ⇒ **不是**菜单授权。 - grant_with_item_type(db, "user", uid, M_USER, "form").await; - - let ids = resolve_user_module_ids(db, uid).await; - assert!( - !ids.contains(M_USER), - "非 module 的授权不得进合并集合:{ids:?}" - ); - assert!( - !has_module(db, uid, 0, "system/User").await, - "只有 f_item_type='module' 的授权才放行菜单" - ); -} - -// ---- 管理员短路 / 未映射放行 / 已映射未授权 ---- - -/// 管理员短路:**不给任何授权**也放行(且短路发生在任何 SQL 之前)。 -#[tokio::test] -async fn administrator_short_circuits_without_any_grant() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_admin_user"; - purge(db, uid).await; - - // 前置条件:库里确实没有这个用户的任何授权行。 - let auths = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_authorize WHERE f_object_id = $1::text", - &[&uid], - ) - .await - .expect("查授权行失败"); - assert!(auths.is_empty(), "前置条件:该用户不得有任何授权行"); - - assert!( - has_module(db, uid, 1, "system/User").await, - "管理员必须短路放行" - ); -} - -/// 未映射放行:`base_module` 里查不到这个 key ⇒ **放行**(不是拒绝)。 -#[tokio::test] -async fn unmapped_module_key_is_allowed() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_unmapped_user"; - purge(db, uid).await; - - assert!( - has_module(db, uid, 0, "not/mapped/anywhere").await, - "未映射到菜单的 key 必须放行(对齐 SswPermissionGuard 的 warn 路径)" - ); -} - -/// 已映射但无授权 ⇒ **拒绝**。 -#[tokio::test] -async fn mapped_module_without_grant_is_denied() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_denied_user"; - purge(db, uid).await; - - // 前置条件:`base_module` 里有 `system/User`(内置菜单 `m_user`)。 - let rows = db - .query_json( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_url_address = 'system/User' AND f_delete_mark = 0", - ) - .await - .expect("查菜单失败"); - assert_eq!(rows.len(), 1, "前置条件:内置菜单 system/User 必须存在"); - - assert!( - !has_module(db, uid, 0, "system/User").await, - "已映射但无授权 ⇒ 必须拒绝" - ); -} - -/// 授权之后立刻放行(四源任一来源命中即可)。 -#[tokio::test] -async fn granted_module_is_allowed_for_non_admin() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_allowed_user"; - purge(db, uid).await; - grant(db, "user", uid, M_USER).await; - - assert!( - has_module(db, uid, 0, "system/User").await, - "已授权的菜单必须放行" - ); - assert!( - !has_module(db, uid, 0, "system/Role").await, - "没授权的菜单必须拒绝" - ); -} - -/// 🔴 **DB 报错 ⇒ 拒**(不是「未映射放行」)+ **管理员在 SQL 之前短路**。 -/// -/// 这是契约 §9「签名没有 `Result`」的承重分支:DB 挂了不能变成「放行一切」 -/// ⇒ 全站越权(且静默)。用「临时删掉 `base_module`」让查菜单这条 SQL 失败。 -/// -/// 同时钉住「管理员在**任何 SQL 之前**短路」:表被 DROP 的那段时间里, -/// 管理员仍然放行 —— 一个「先查 `base_module`、再看 `is_admin`」的实现会挂。 -#[tokio::test] -async fn db_error_denies_instead_of_allowing() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_dberror_user"; - let admin_uid = "perm_it_dberror_admin"; - purge(db, uid).await; - purge(db, admin_uid).await; - - // 让「查菜单」这条 SQL **失败**(表被临时删掉)⇒ 必须走「查询失败 ⇒ 拒」的分支。 - db.exec("DROP TABLE base_module") - .await - .expect("临时删表失败"); - let mapped = has_module(db, uid, 0, "system/User").await; - let unmapped = has_module(db, uid, 0, "not/mapped/anywhere").await; - // 🔴 管理员:**SQL 之前**就短路 ⇒ 表都不在也照样放行。 - let admin = has_module(db, admin_uid, 1, "system/User").await; - - // 🔴 **先恢复表,再断言** —— 断言失败也不会污染同文件的其它测试。 - restore_base_module(db).await; - ensure_base(db).await.expect("恢复后 ensure_base 失败"); - - assert!( - !mapped, - "DB 报错必须拒(false)—— 绝不能当成「未映射」放行" - ); - assert!( - !unmapped, - "DB 报错必须拒(false)—— 绝不能当成「未映射」放行" - ); - assert!( - admin, - "管理员必须在任何 SQL 之前短路放行(查表失败也不影响)" - ); -} - -/// 把 `base_module` 的建表语句从 `schema.sql` 里捞出来重建(测试专用)。 -async fn restore_base_module(db: &Db) { - let ddl = ssw_jnpf_lite_rust::platform::db::split_sql_statements(ssw_jnpf_lite_rust::platform::db::SCHEMA_SQL) - .into_iter() - .find(|s| s.contains("CREATE TABLE base_module")) - .expect("schema.sql 里必须有 base_module 的建表语句"); - db.exec(&ddl).await.expect("恢复 base_module 失败"); -} - -// ---- 菜单树 ---- -/// 管理员看全部 8 个内置菜单 ⇒ 树形字符串逐字相等(契约 §8.4)。 -#[tokio::test] -async fn admin_menu_tree_matches_contract_string() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_tree_admin"; - purge(db, uid).await; - - let roots = build_menu_list(db, uid, 1).await; - assert_eq!( - render_tree(&roots), - EXPECTED_ADMIN_TREE, - "管理员菜单树必须逐字等于契约里的期望串" - ); -} - -/// 非管理员只授权 `m_demo` ⇒ 菜单树 == `Demo 示例:`。 -#[tokio::test] -async fn non_admin_menu_tree_is_filtered() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_tree_user"; - purge(db, uid).await; - grant(db, "user", uid, M_DEMO).await; - - let roots = build_menu_list(db, uid, 0).await; - assert_eq!( - render_tree(&roots), - "Demo 示例:", - "非管理员的菜单树必须只含被授权的菜单" - ); -} - -/// 🔴 **父不在可见集合内 ⇒ 自己就是根**(逐字对齐 react 的 `toTree`), -/// 且节点的 `parentId` 仍保留原始父 id(不是被改成 `'0'`)。 -#[tokio::test] -async fn node_with_invisible_parent_becomes_root() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_orphan_user"; - purge(db, uid).await; - // 只授权子菜单 `m_user`(父 `m_sys` 没授权 ⇒ 父不在可见集合内)。 - grant(db, "user", uid, M_USER).await; - - let roots = build_menu_list(db, uid, 0).await; - assert_eq!( - render_tree(&roots), - "用户管理:", - "父不可见的子菜单必须自己成为根" - ); - assert_eq!(roots.len(), 1, "只应有一个根节点"); - assert_eq!(roots[0].id, M_USER); - assert_eq!( - roots[0].parent_id, M_SYS, - "parentId 必须保留原始父 id(不是 '0')" - ); -} - -/// 节点 JSON 形状:6 个键固定存在;`icon` 为 NULL ⇒ 键仍在、值为 `null`。 -#[tokio::test] -async fn menu_node_json_shape() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_shape_user"; - purge(db, uid).await; - grant(db, "user", uid, M_USER).await; - - let roots = build_menu_list(db, uid, 0).await; - let json = serde_json::to_value(&roots[0]).expect("序列化 MenuNode 失败"); - let obj = json.as_object().expect("MenuNode 必须序列化成对象"); - for key in ["id", "fullName", "urlAddress", "icon", "parentId", "children"] { - assert!(obj.contains_key(key), "JSON 必须含键 {key}:{json}"); - } - assert_eq!(obj["id"], M_USER); - assert_eq!(obj["fullName"], "用户管理"); - assert_eq!(obj["urlAddress"], "system/User"); - assert!( - obj["icon"].is_null(), - "icon 为 NULL 时键仍在、值为 null:{json}" - ); - assert_eq!(obj["parentId"], M_SYS); - assert!( - obj["children"].is_array(), - "children 恒存在(无子节点 ⇒ []):{json}" - ); -} - -/// 根节点按 `f_sort_code` 升序;同层 children 也按 `f_sort_code` 升序。 -#[tokio::test] -async fn roots_and_children_are_sorted_by_sort_code() { - let db = db().await; - let _guard = LOCK.lock().await; - - ensure_base(db).await.expect("ensure_base 失败"); - let uid = "perm_it_sort_user"; - purge(db, uid).await; - - let roots = build_menu_list(db, uid, 1).await; - let ids: Vec<&str> = roots.iter().map(|r| r.id.as_str()).collect(); - assert_eq!( - ids, - vec![M_SYS, M_DEMO, M_PRODUCT, M_BOOK], - "根节点必须按 f_sort_code 升序" - ); - let kids: Vec<&str> = roots[0].children.iter().map(|c| c.id.as_str()).collect(); - assert_eq!( - kids, - vec![M_USER, M_ROLE, M_ORG, M_MENU], - "同层 children 必须按 f_sort_code 升序" - ); -} diff --git a/src/backend/tests/seed_it.rs b/src/backend/tests/seed_it.rs deleted file mode 100644 index b424a2b..0000000 --- a/src/backend/tests/seed_it.rs +++ /dev/null @@ -1,509 +0,0 @@ -//! seed 集成测试 —— 两段式种子(`ensure_base` 幂等 + `first_seed` 首启)。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** -//! (`OnceCell` 起一次),不每个测试函数各开一个。 -//! -//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 -//! `#[tokio::test]` **并发**跑(不同线程)⇒ 共用一个库时它们会互相踩数据。 -//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 -//! 🔴 **不依赖测试执行顺序**:每个测试自己先清库 + 重新种子,造出确定的前置条件。 - -use ssw_jnpf_lite_rust::platform::cipher::md5_hex; -use ssw_jnpf_lite_rust::platform::db::Db; -use ssw_jnpf_lite_rust::bootstrap::ensure_base; -use ssw_jnpf_lite_rust::platform::seed::first_seed; -use tokio::sync::{Mutex, OnceCell}; - -/// 全文件共享的临时库。 -static DB: OnceCell = OnceCell::const_new(); - -/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 -static LOCK: Mutex<()> = Mutex::const_new(()); - -async fn db() -> &'static Db { - DB.get_or_init(|| async { - let db = Db::open_temp() - .await - .expect("打开 pglite 临时库失败"); - db.ensure_schema().await.expect("ensure_schema 失败"); - db - }) - .await -} - -/// 内置菜单的期望值(契约 §8.4)—— 逐字照抄那张表。 -/// -/// `(id, fullName, parentId, type, sortCode, icon)` -/// —— 🔴 `type` 是 **INTEGER**(1=目录 / 2=页面);`icon` 为 `None` ⇒ 期望 **NULL**。 -const BUILTIN_MENUS: [(&str, &str, &str, i64, i64, Option<&str>); 8] = [ - ("m_sys", "系统管理", "0", 1, 1, Some("setting")), - ("m_user", "用户管理", "m_sys", 2, 2, None), - ("m_role", "角色管理", "m_sys", 2, 3, None), - ("m_org", "机构管理", "m_sys", 2, 4, None), - ("m_menu", "菜单管理", "m_sys", 2, 5, None), - ("m_demo", "Demo 示例", "0", 2, 6, Some("app")), - ("m_product", "产品管理", "0", 2, 7, Some("app")), - ("m_book", "图书超市", "0", 2, 8, Some("app")), -]; - -/// 内置角色的期望值(契约 §8.5)—— `(id, enCode, fullName, sortCode)`。 -const BUILTIN_ROLES: [(&str, &str, &str, i64); 2] = [ - ("role_admin", "admin", "管理员", 1), - ("role_user", "user", "使用者", 2), -]; - -/// 用户自建的 admin 角色用的随机 UUID(**不是** `role_admin`)—— 契约 §8.6 的分支。 -const CUSTOM_ADMIN_ROLE_ID: &str = "77777777-7777-4777-8777-777777777777"; - -/// 清空种子相关的 5 张表(造「空库」前置条件)。 -/// -/// 🔴 不依赖「这个测试恰好第一个跑」—— test harness 的执行顺序**不保证**。 -async fn clear_all(db: &Db) { - db.exec( - "DELETE FROM base_authorize; \ - DELETE FROM base_role_relation; \ - DELETE FROM base_user; \ - DELETE FROM base_module; \ - DELETE FROM base_role;", - ) - .await - .expect("清库失败"); -} - -/// 清库 + 走一遍**生产顺序**的种子(契约 §10:`ensure_base` → `first_seed`)。 -async fn reset_and_seed(db: &Db) { - clear_all(db).await; - ensure_base(db).await.expect("ensure_base 失败"); - first_seed(db, "123456").await.expect("first_seed 失败"); -} - -/// 计数(`scalar_text` ⇒ 十进制文本)。 -async fn count(db: &Db, sql: &str) -> i64 { - let raw = db.scalar_text(sql).await.expect("count 失败"); - raw.expect("count(*) 恒有一行") - .parse::() - .expect("count(*) 必须是十进制文本") -} - -/// 五张种子相关表的行数快照。 -#[derive(Debug, PartialEq, Eq)] -struct Counts { - user: i64, - role: i64, - module: i64, - authorize: i64, - role_relation: i64, -} - -async fn counts(db: &Db) -> Counts { - Counts { - user: count(db, "SELECT count(*) FROM base_user").await, - role: count(db, "SELECT count(*) FROM base_role").await, - module: count(db, "SELECT count(*) FROM base_module").await, - authorize: count(db, "SELECT count(*) FROM base_authorize").await, - role_relation: count(db, "SELECT count(*) FROM base_role_relation").await, - } -} - -/// 空库启动 ⇒ admin/123456 + 2 角色 + 8 菜单 + admin 对 8 个内置菜单的授权。 -#[tokio::test] -async fn empty_db_seeds_admin_roles_menus_and_authorizations() { - let db = db().await; - let _guard = LOCK.lock().await; - - reset_and_seed(db).await; - - // ---- base_user:1 行 admin ---- - let users = db - .query_json( - "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \ - f_password AS \"password\", f_is_administrator AS \"isAdministrator\", \ - f_organize_id AS \"organizeId\", f_enabled_mark AS \"enabledMark\", \ - f_delete_mark AS \"deleteMark\", f_tenant_id AS \"tenantId\" \ - FROM base_user", - ) - .await - .expect("读 base_user 失败"); - assert_eq!( - users.len(), - 1, - "base_user 应只有 1 行(admin),实际 {:?}", - users.len() - ); - let u = &users[0]; - assert_eq!(u["account"], "admin", "账号必须是 admin"); - assert_eq!(u["realName"], "管理员", "姓名必须是 管理员"); - assert_eq!( - u["password"], - md5_hex("123456"), - "口令必须是 md5_hex(\"123456\")" - ); - assert_eq!(u["isAdministrator"].as_i64(), Some(1), "必须是管理员"); - assert_eq!(u["organizeId"], "0"); - assert_eq!(u["enabledMark"].as_i64(), Some(1)); - assert_eq!(u["deleteMark"].as_i64(), Some(0)); - assert_eq!(u["tenantId"], "0"); - assert_eq!( - u["id"].as_str().map(str::len), - Some(36), - "用户主键应是 36 位 UUID v4" - ); - - // ---- base_role:admin / user 两行(§8.5 的 id / enCode / fullName / sortCode 逐条钉死)---- - let roles = db - .query_json( - "SELECT f_id AS \"id\", f_en_code AS \"enCode\", f_full_name AS \"fullName\", \ - f_type AS \"type\", f_sort_code AS \"sortCode\", \ - f_enabled_mark AS \"enabledMark\", f_delete_mark AS \"deleteMark\", \ - f_tenant_id AS \"tenantId\" FROM base_role ORDER BY f_sort_code", - ) - .await - .expect("读 base_role 失败"); - assert_eq!(roles.len(), 2, "base_role 应有 2 行,实际 {}", roles.len()); - for (i, (id, en_code, full_name, sort_code)) in BUILTIN_ROLES.iter().enumerate() { - let r = &roles[i]; - assert_eq!(r["id"], *id, "第 {i} 个内置角色的 id 不对"); - assert_eq!(r["enCode"], *en_code, "第 {i} 个内置角色的 enCode 不对"); - assert_eq!(r["fullName"], *full_name, "第 {i} 个内置角色的全名不对"); - assert_eq!(r["sortCode"].as_i64(), Some(*sort_code), "第 {i} 个内置角色的 sortCode 不对"); - assert_eq!(r["type"], "user", "内置角色的 f_type 必须是 'user'"); - assert_eq!(r["enabledMark"].as_i64(), Some(1)); - assert_eq!(r["deleteMark"].as_i64(), Some(0)); - assert_eq!(r["tenantId"], "0"); - } - - // ---- base_module:8 行内置菜单(§8.4 逐条钉死)---- - let modules = db - .query_json( - "SELECT f_id AS \"id\", f_url_address AS \"urlAddress\", \ - f_full_name AS \"fullName\", f_parent_id AS \"parentId\", \ - f_type AS \"type\", f_icon AS \"icon\", f_sort_code AS \"sortCode\", \ - f_enabled_mark AS \"enabledMark\", f_delete_mark AS \"deleteMark\", \ - f_tenant_id AS \"tenantId\" \ - FROM base_module ORDER BY f_sort_code", - ) - .await - .expect("读 base_module 失败"); - assert_eq!( - modules.len(), - 8, - "base_module 应有 8 行,实际 {}", - modules.len() - ); - for (i, (id, full_name, parent_id, menu_type, sort_code, icon)) in - BUILTIN_MENUS.iter().enumerate() - { - let m = &modules[i]; - assert_eq!(m["id"], *id, "第 {i} 个内置菜单的 id 不对"); - assert_eq!(m["fullName"], *full_name, "第 {i} 个内置菜单的全名不对"); - assert_eq!(m["parentId"], *parent_id, "第 {i} 个内置菜单的 parentId 不对"); - // 🔴 `f_type` 是 **INTEGER**(1=目录 / 2=页面),不是字符串。 - assert_eq!( - m["type"].as_i64(), - Some(*menu_type), - "第 {i} 个内置菜单的 f_type 不对(1=目录 / 2=页面)" - ); - assert_eq!( - m["sortCode"].as_i64(), - Some(*sort_code), - "第 {i} 个内置菜单的 sortCode 不对" - ); - match icon { - // 🔴 `None` ⇒ 必须是 **NULL**(不是空串)。 - None => assert!( - m["icon"].is_null(), - "第 {i} 个内置菜单的 icon 必须是 NULL,实际 {}", - m["icon"] - ), - Some(expected) => assert_eq!( - m["icon"], *expected, - "第 {i} 个内置菜单的 icon 不对" - ), - } - assert_eq!(m["enabledMark"].as_i64(), Some(1)); - assert_eq!(m["deleteMark"].as_i64(), Some(0)); - assert_eq!(m["tenantId"], "0"); - } - - // ---- base_authorize:admin 角色对 8 个内置菜单都有授权 ---- - let auths = db - .query_json( - "SELECT f_object_type AS \"objectType\", f_object_id AS \"objectId\", \ - f_item_type AS \"itemType\", f_item_id AS \"itemId\", \ - f_sort_code AS \"sortCode\", f_delete_mark AS \"deleteMark\", \ - f_tenant_id AS \"tenantId\" FROM base_authorize", - ) - .await - .expect("读 base_authorize 失败"); - assert_eq!( - auths.len(), - 8, - "base_authorize 应有 8 行,实际 {}", - auths.len() - ); - for a in &auths { - assert_eq!(a["objectType"], "role"); - assert_eq!(a["objectId"], "role_admin", "授权对象必须是 admin 角色"); - assert_eq!(a["itemType"], "module"); - assert_eq!(a["sortCode"].as_i64(), Some(0)); - assert_eq!(a["deleteMark"].as_i64(), Some(0)); - assert_eq!(a["tenantId"], "0"); - } - // 8 个内置菜单**各一条**(不重复、不缺)。 - let mut item_ids: Vec<&str> = auths.iter().map(|a| a["itemId"].as_str().unwrap()).collect(); - item_ids.sort_unstable(); - let mut expected: Vec<&str> = BUILTIN_MENUS.iter().map(|(id, ..)| *id).collect(); - expected.sort_unstable(); - assert_eq!(item_ids, expected, "授权的菜单集合必须与内置清单逐条相等"); - - // ---- base_role_relation:admin → role_admin ---- - // - // 🔴 官方 DDL 陷阱:`base_role_relation` 没有 `f_user_id` —— 用户标识在 `f_object_id`。 - let rels = db - .query_json( - "SELECT f_role_id AS \"roleId\", f_object_type AS \"objectType\", \ - f_object_id AS \"objectId\", f_sort_code AS \"sortCode\", \ - f_delete_mark AS \"deleteMark\", f_tenant_id AS \"tenantId\" \ - FROM base_role_relation", - ) - .await - .expect("读 base_role_relation 失败"); - assert_eq!( - rels.len(), - 1, - "base_role_relation 应有 1 行,实际 {}", - rels.len() - ); - assert_eq!(rels[0]["objectType"], "user"); - assert_eq!(rels[0]["objectId"], "admin", "用户标识是**账号名** 'admin'"); - assert_eq!(rels[0]["roleId"], "role_admin"); - assert_eq!(rels[0]["sortCode"].as_i64(), Some(0)); - assert_eq!(rels[0]["deleteMark"].as_i64(), Some(0)); - assert_eq!(rels[0]["tenantId"], "0"); -} - -/// 再启动一次 ⇒ 库内容**完全不变**(`first_seed` 此时不跑,`base_user` 仍 1 行)。 -#[tokio::test] -async fn rerunning_seed_changes_nothing() { - let db = db().await; - let _guard = LOCK.lock().await; - - reset_and_seed(db).await; - let before = counts(db).await; - assert_eq!(before.user, 1, "首启后 base_user 只有 1 行"); - - // 再跑一次(顺序刻意与首启相反:先 first_seed 后 ensure_base)。 - first_seed(db, "123456").await.expect("二次 first_seed 失败"); - ensure_base(db).await.expect("二次 ensure_base 失败"); - - let after = counts(db).await; - assert_eq!(before, after, "二次种子后各表行数必须完全不变"); - assert_eq!(after.user, 1, "base_user 仍是 1 行(不是 2 行)"); - assert_eq!(after.role, 2); - assert_eq!(after.module, 8); - assert_eq!(after.authorize, 8); - assert_eq!(after.role_relation, 1); -} - -/// 软删一行内置菜单 ⇒ 再跑 `ensure_base` ⇒ **不复活**、行数不变。 -#[tokio::test] -async fn soft_deleted_builtin_menu_is_not_revived() { - let db = db().await; - let _guard = LOCK.lock().await; - - reset_and_seed(db).await; - db.exec("UPDATE base_module SET f_delete_mark = 1 WHERE f_id = 'm_user'") - .await - .expect("软删 m_user 失败"); - let before = counts(db).await; - - ensure_base(db).await.expect("ensure_base 失败"); - - let after = counts(db).await; - assert_eq!( - before.module, after.module, - "软删的行不得被复活(行数必须不变)" - ); - assert_eq!(after.module, 8, "base_module 仍是 8 行"); - - let rows = db - .query_json( - "SELECT f_id AS \"id\", f_delete_mark AS \"deleteMark\" FROM base_module \ - WHERE f_id = 'm_user'", - ) - .await - .expect("读 m_user 失败"); - assert_eq!(rows.len(), 1, "m_user 行仍在(没被删)"); - assert_eq!( - rows[0]["deleteMark"].as_i64(), - Some(1), - "m_user 必须仍是软删状态(不被复活)" - ); -} - -/// 改内置角色的全名 ⇒ 再跑 `ensure_base` ⇒ **不被覆盖**。 -#[tokio::test] -async fn renamed_builtin_role_is_not_overwritten() { - let db = db().await; - let _guard = LOCK.lock().await; - - reset_and_seed(db).await; - db.exec("UPDATE base_role SET f_full_name = '超级管理员' WHERE f_en_code = 'admin'") - .await - .expect("改角色名失败"); - - ensure_base(db).await.expect("ensure_base 失败"); - - let rows = db - .query_json( - "SELECT f_full_name AS \"fullName\" FROM base_role WHERE f_en_code = 'admin'", - ) - .await - .expect("读角色失败"); - assert_eq!(rows.len(), 1); - assert_eq!( - rows[0]["fullName"], "超级管理员", - "人工改过的名字不得被种子覆盖" - ); -} - -/// 用户改过内置菜单的 `f_url_address` ⇒ 再跑 `ensure_base` ⇒ **不报错**、 -/// 行数不变、**用户改的值不被覆盖**。 -/// -/// 🔴 回归意义:只按 url 判存在 ⇒ 「查不到 ⇒ INSERT 固定 id `m_user`」⇒ 撞复合主键 -/// ⇒ 种子失败 ⇒ 进程 exit 1 ⇒ 此后每次启动都失败(且服务起不来 ⇒ 用户没法用 UI 改回去)。 -#[tokio::test] -async fn user_edited_builtin_menu_url_does_not_break_seeding() { - let db = db().await; - let _guard = LOCK.lock().await; - - reset_and_seed(db).await; - db.exec("UPDATE base_module SET f_url_address = 'system/UserCustom' WHERE f_id = 'm_user'") - .await - .expect("改菜单 url 失败"); - let before = counts(db).await; - - // 🔴 关键:这里**不能**报错(旧实现会撞主键 ⇒ Err ⇒ 种子失败 ⇒ 进程 exit 1)。 - ensure_base(db).await.expect("ensure_base 失败"); - - let after = counts(db).await; - assert_eq!(before, after, "用户改过 url 后,各表行数必须完全不变"); - assert_eq!(after.module, 8, "base_module 仍是 8 行(不得多插一行)"); - - let rows = db - .query_json( - "SELECT f_url_address AS \"urlAddress\" FROM base_module WHERE f_id = 'm_user'", - ) - .await - .expect("读 m_user 失败"); - assert_eq!(rows.len(), 1, "m_user 行仍在(没被删也没被复制)"); - assert_eq!( - rows[0]["urlAddress"], "system/UserCustom", - "用户改过的 url 不得被种子覆盖" - ); -} - -/// 用户改过内置角色的 `f_en_code` ⇒ 再跑 `ensure_base` ⇒ **不报错**、 -/// 行数不变、**用户改的值不被覆盖**。 -/// -/// 🔴 回归意义:只按 en_code 判存在 ⇒ 「查不到 ⇒ INSERT 固定 id `role_admin`」⇒ 撞复合主键。 -#[tokio::test] -async fn user_edited_builtin_role_en_code_does_not_break_seeding() { - let db = db().await; - let _guard = LOCK.lock().await; - - reset_and_seed(db).await; - db.exec("UPDATE base_role SET f_en_code = 'adminCustom' WHERE f_id = 'role_admin'") - .await - .expect("改角色 enCode 失败"); - let before = counts(db).await; - - // 🔴 关键:这里**不能**报错(旧实现会撞主键 ⇒ Err ⇒ 种子失败 ⇒ 进程 exit 1)。 - ensure_base(db).await.expect("ensure_base 失败"); - - let after = counts(db).await; - assert_eq!(before, after, "用户改过 enCode 后,各表行数必须完全不变"); - assert_eq!(after.role, 2, "base_role 仍是 2 行(不得多插一行)"); - - let rows = db - .query_json( - "SELECT f_en_code AS \"enCode\" FROM base_role WHERE f_id = 'role_admin'", - ) - .await - .expect("读 role_admin 失败"); - assert_eq!(rows.len(), 1, "role_admin 行仍在(没被删也没被复制)"); - assert_eq!( - rows[0]["enCode"], "adminCustom", - "用户改过的 enCode 不得被种子覆盖" - ); -} - -/// admin 角色是**用户自建的行**(`f_id` ≠ `role_admin`)⇒ 授权行必须挂在那个随机 UUID 上, -/// 且**不得**有任何授权行挂在 `role_admin` 上(契约 §8.6)。 -#[tokio::test] -async fn admin_role_created_by_user_receives_authorizations() { - let db = db().await; - let _guard = LOCK.lock().await; - - clear_all(db).await; - // 用户自建的 admin 角色:`f_en_code='admin'`,但 `f_id` 是随机 UUID(**不是** `role_admin`)。 - db.exec_params( - "INSERT INTO base_role (f_id, f_full_name, f_en_code, f_type, f_sort_code, \ - f_enabled_mark, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, '我的管理员', 'admin', 'user', $2::text::bigint, \ - $3::text::integer, $4::text::integer, $5::text)", - &[&CUSTOM_ADMIN_ROLE_ID, &"9", &"1", &"0", &"0"], - ) - .await - .expect("插入用户自建 admin 角色失败"); - - ensure_base(db).await.expect("ensure_base 失败"); - - // ---- base_role:用户那行 + 被补上的 `role_user`;**不得**再有 `role_admin` ---- - let roles = db - .query_json( - "SELECT f_id AS \"id\", f_en_code AS \"enCode\" FROM base_role ORDER BY f_id", - ) - .await - .expect("读 base_role 失败"); - assert_eq!(roles.len(), 2, "base_role 应是「用户自建 admin + role_user」两行"); - assert!( - roles.iter().any(|r| r["id"] == CUSTOM_ADMIN_ROLE_ID), - "用户自建的 admin 角色必须还在" - ); - assert!( - !roles.iter().any(|r| r["id"] == "role_admin"), - "en_code='admin' 已被占用 ⇒ 不得再插入 role_admin" - ); - assert!( - roles.iter().any(|r| r["id"] == "role_user"), - "缺失的 role_user 应被补上" - ); - - // ---- 授权行必须挂在那个随机 UUID 上 ---- - let auths = db - .query_json( - "SELECT f_object_id AS \"objectId\", f_item_type AS \"itemType\", \ - f_item_id AS \"itemId\" FROM base_authorize", - ) - .await - .expect("读 base_authorize 失败"); - assert_eq!( - auths.len(), - 8, - "admin 角色应对 8 个内置菜单都有授权,实际 {}", - auths.len() - ); - for a in &auths { - assert_eq!( - a["objectId"], CUSTOM_ADMIN_ROLE_ID, - "授权必须挂在**真实**的 admin 角色行上" - ); - assert_eq!(a["itemType"], "module"); - } - assert!( - !auths.iter().any(|a| a["objectId"] == "role_admin"), - "不得有任何授权行挂在 role_admin 上" - ); -} diff --git a/src/backend/tests/sys_it.rs b/src/backend/tests/sys_it.rs deleted file mode 100644 index a8b4655..0000000 --- a/src/backend/tests/sys_it.rs +++ /dev/null @@ -1,1883 +0,0 @@ -//! sys 集成测试 —— 5 组 `base_*` CRUD + 授权写入。 -//! -//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 -//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** -//! (`OnceCell` 起一次),不每个测试函数各开一个。 -//! -//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 -//! `#[tokio::test]` **并发**跑(不同线程)⇒ 共用一个库时它们会互相踩数据。 -//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 -//! 🔴 **不依赖测试执行顺序**:每个测试用**自己专属**的账号 / 编码 / 名称, -//! 需要「不存在」前置条件的 ⇒ 自己先 `DELETE` 造出前置条件再断言。 - -use std::path::PathBuf; -use std::sync::Arc; - -use axum::body::Bytes; -use axum::extract::{Path, RawQuery, State}; -use axum::http::{HeaderMap, HeaderValue}; -use serde_json::{json, Value}; -use ssw_jnpf_lite_rust::platform::cipher::md5_hex; -use ssw_jnpf_lite_rust::platform::config::Config; -use ssw_jnpf_lite_rust::platform::db::Db; -use ssw_jnpf_lite_rust::platform::envelope::ActionResult; -use ssw_jnpf_lite_rust::bootstrap::ensure_base; -use ssw_jnpf_lite_rust::platform::seed::first_seed; -use ssw_jnpf_lite_rust::platform::session::SessionStore; -use ssw_jnpf_lite_rust::platform::state::AppState; -use ssw_jnpf_lite_rust::platform::sys; -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 -} - -/// 造一个应用状态(**每个测试自己一份** ⇒ token 表互不干扰)。 -fn new_state(db: &Db) -> AppState { - AppState { - config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-jnpf-lite-rust-sys-it"))), - db: Arc::new(db.clone()), - sessions: Arc::new(SessionStore::new()), - } -} - -/// 取种子 admin 的用户 id。 -async fn admin_id(db: &Db) -> String { - let rows = db - .query_json("SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1") - .await - .expect("查 admin 失败"); - rows.first() - .and_then(|r| r.get("id")) - .and_then(Value::as_str) - .expect("种子里必须有 admin 用户") - .to_string() -} - -/// 造一个**管理员** token(管理员短路 ⇒ 菜单守卫直接放行)。 -async fn admin_state(db: &Db) -> (AppState, HeaderMap) { - let state = new_state(db); - let id = admin_id(db).await; - let token = state.sessions.issue("admin", &id, 1); - (state, auth_headers(&token)) -} - -/// 带 `bearer ` 的请求头。 -fn auth_headers(token: &str) -> HeaderMap { - let mut headers = HeaderMap::new(); - let value = - HeaderValue::from_str(&format!("bearer {}", token)).expect("token 必须是合法 header 值"); - headers.insert("authorization", value); - headers -} - -/// 空请求头(未登录)。 -fn anon_headers() -> HeaderMap { - HeaderMap::new() -} - -/// 造一个 query。 -fn query(raw: &str) -> RawQuery { - RawQuery(Some(raw.to_string())) -} - -/// 造一个**完全没有 query** 的 `RawQuery`(`RawQuery(None)`)。 -fn query_none() -> RawQuery { - RawQuery(None) -} - -/// 从信封里取 `data`(`data` 必须是对象 / 数组时才返回 `Some`)。 -fn data_obj(r: &ActionResult) -> Value { - r.data.clone() -} - -// ---------------------------------------------------------------- 用户 - -/// 新建用户 ⇒ `code=200`、`data.id` 长度 36、**响应里没有 `password` 键**。 -#[tokio::test] -async fn user_save_creates_user_and_never_returns_password() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'smoke_user'") - .await - .expect("清理失败"); - - let r = sys::user_save( - State(state.clone()), - headers, - Bytes::from(json!({"account": "smoke_user", "realName": "冒烟用户"}).to_string()), - ) - .await - .0; - - assert_eq!(r.code, 200, "新建用户应成功,实际 msg={}", r.msg); - let data = data_obj(&r); - let id = data["id"].as_str().expect("响应必须有 id"); - assert_eq!(id.len(), 36, "主键必须是 36 位 UUID:{id}"); - assert_eq!(data["account"], "smoke_user"); - assert_eq!(data["realName"], "冒烟用户"); - // 🔴 键名必须是契约的 camelCase(PG 会把未加引号的别名折叠成小写 ⇒ 静默读不到)。 - assert!(data.get("isAdministrator").is_some(), "缺 isAdministrator:{data}"); - assert!(data.get("creatorTime").is_some(), "缺 creatorTime:{data}"); - assert!(data.get("deleteMark").is_some(), "缺 deleteMark:{data}"); - assert!( - data.get("isadministrator").is_none() && data.get("realname").is_none(), - "不许出现折叠成小写的键:{data}" - ); - // 🔴 唯一与 react 的刻意偏离(契约 §7.7):Save 响应**不带 `password`**。 - assert!( - data.get("password").is_none(), - "响应里不许出现 password 键:{data}" - ); - // 追加的两个数组字段。 - assert!(data["roleIds"].is_array(), "必须有 roleIds 数组:{data}"); - assert!(data["roleNames"].is_array(), "必须有 roleNames 数组:{data}"); -} - -/// 重复账号 ⇒ `code=400`、`msg == "账号已存在:smoke_user"`(**不是 500**)。 -#[tokio::test] -async fn duplicate_account_is_a_business_error_not_a_500() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'smoke_user'") - .await - .expect("清理失败"); - - let body = json!({"account": "smoke_user"}).to_string(); - let first = sys::user_save(State(state.clone()), headers.clone(), Bytes::from(body.clone())) - .await - .0; - assert_eq!(first.code, 200, "第一次新建应成功"); - - let second = sys::user_save(State(state.clone()), headers, Bytes::from(body)) - .await - .0; - assert_eq!(second.code, 400, "重复账号必须是业务失败 code=400"); - assert_eq!(second.msg, "账号已存在:smoke_user"); - assert_eq!(second.data, Value::Null, "失败时 data 必须是 null"); -} - -/// 空账号 ⇒ `code=400`、`msg == "账号不能为空"`。 -#[tokio::test] -async fn empty_account_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::user_save( - State(state), - headers, - Bytes::from(json!({"account": "", "realName": "空"}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "账号不能为空"); -} - -/// User List ⇒ 数组;**每个元素都没有 `password`**,且都含 `roleIds` / `roleNames`。 -#[tokio::test] -async fn user_list_has_no_password_and_carries_roles() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'smoke_list_user'") - .await - .expect("清理失败"); - - // 建一个带角色的用户(`role_admin` 是种子角色)。 - let created = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({ - "account": "smoke_list_user", - "realName": "列表用户", - "roleIds": ["role_admin", "no_such_role_id"] - }) - .to_string(), - ), - ) - .await - .0; - assert_eq!(created.code, 200, "新建应成功:{}", created.msg); - let uid = created.data["id"].as_str().expect("必须有 id").to_string(); - - // 🔴 `roleIds` 传**非字符串元素**(`[123]`)⇒ 这是**非法输入**,不是「清空角色」 - // ⇒ 已有角色关系行**不得**被硬删(修复轮 R=1 必改 3)。 - let bad_roles = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"id": uid, "account": "smoke_list_user", "roleIds": [123]}).to_string(), - ), - ) - .await - .0; - assert_eq!(bad_roles.code, 200, "非法 roleIds 不该报错:{}", bad_roles.msg); - let rels = db - .query_json_params( - "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text", - &[&uid], - ) - .await - .expect("查角色关系失败"); - assert_eq!( - rels.len(), - 2, - "非法 roleIds 不得清空已有角色关系:{rels:?}" - ); - - let r = sys::user_list(State(state), headers).await.0; - assert_eq!(r.code, 200); - let items = r.data.as_array().expect("List 必须返回数组"); - assert!(!items.is_empty(), "List 不该是空数组"); - - for item in items { - assert!( - item.get("password").is_none(), - "列表元素不许出现 password 键:{item}" - ); - assert!(item.get("roleIds").is_some(), "元素必须有 roleIds:{item}"); - assert!(item.get("roleNames").is_some(), "元素必须有 roleNames:{item}"); - } - - let mine = items - .iter() - .find(|i| i["account"] == "smoke_list_user") - .expect("列表里必须有新建的用户"); - let role_ids = mine["roleIds"].as_array().expect("roleIds 是数组"); - assert_eq!(role_ids.len(), 2, "roleIds 保留两条关系(含查不到的角色):{mine}"); - // 🔴 `roleNames` 查不到就**跳过** ⇒ 长度可能小于 `roleIds`。 - let role_names = mine["roleNames"].as_array().expect("roleNames 是数组"); - assert_eq!(role_names.len(), 1, "查不到的角色不占位:{mine}"); - assert_eq!(role_names[0], "管理员"); -} - -/// 更新已有用户时 **body 没有 `password` ⇒ 库里口令不变**(裁决 S16)。 -#[tokio::test] -async fn user_update_keeps_password_when_body_omits_it() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'smoke_pwd_user'") - .await - .expect("清理失败"); - - let created = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"account": "smoke_pwd_user", "password": "s3cret"}).to_string()), - ) - .await - .0; - assert_eq!(created.code, 200); - let id = created.data["id"].as_str().expect("必须有 id").to_string(); - - let updated = sys::user_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": id, "account": "smoke_pwd_user", "realName": "改名"}).to_string()), - ) - .await - .0; - assert_eq!(updated.code, 200, "更新应成功:{}", updated.msg); - assert!( - updated.data.get("password").is_none(), - "更新响应也不许出现 password:{}", - updated.data - ); - - let rows = db - .query_json_params( - "SELECT f_password AS \"password\" FROM base_user WHERE f_id = $1::text", - &[&id], - ) - .await - .expect("查口令失败"); - assert_eq!( - rows[0]["password"].as_str(), - Some(md5_hex("s3cret").as_str()), - "body 没给 password ⇒ 原口令不得被覆盖" - ); -} - -/// 更新不存在的用户 ⇒ `code=400`、`msg == "用户不存在"`。 -#[tokio::test] -async fn user_update_of_missing_id_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"id": "00000000-0000-4000-8000-000000000000", "account": "ghost_x"}) - .to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "用户不存在"); - - // 🔴 `id` 是**非字符串**(数字 `123`)⇒ react 的 `if (dto.id)` 是 truthy - // ⇒ 走**更新**分支(查不到 ⇒ `用户不存在`),**不是**新建一行 - // (修复轮 R=1 必改 2)。 - let before = count_users(db).await; - let r = sys::user_save( - State(state), - headers, - Bytes::from(json!({"id": 123, "account": "ghost_numeric_id"}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 400, "非字符串 id 必须走更新分支"); - assert_eq!(r.msg, "用户不存在"); - assert_eq!( - count_users(db).await, - before, - "非字符串 id 不得插出一行新记录" - ); - db.exec("DELETE FROM base_user WHERE f_account = 'ghost_numeric_id'") - .await - .expect("自清失败"); -} - -/// 统计 `base_user` 的行数。 -async fn count_users(db: &Db) -> i64 { - let raw = db - .scalar_text("SELECT count(*) FROM base_user") - .await - .expect("count 失败"); - raw.expect("count(*) 恒有一行") - .parse::() - .expect("count(*) 必须是十进制文本") -} - -/// 删除用户 ⇒ 软删 + 角色关系被硬删;再删一次也成功(幂等)。 -#[tokio::test] -async fn user_delete_is_soft_and_idempotent() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'smoke_del_user'") - .await - .expect("清理失败"); - let created = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"account": "smoke_del_user", "roleIds": ["role_admin"]}).to_string(), - ), - ) - .await - .0; - assert_eq!(created.code, 200); - let id = created.data["id"].as_str().expect("必须有 id").to_string(); - - let r = sys::user_delete(State(state.clone()), headers.clone(), query(&format!("id={id}"))) - .await - .0; - assert_eq!(r.code, 200, "删除应成功"); - - // 软删:行还在,但 `f_delete_mark = 1` ⇒ List 里看不到。 - let rows = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_user WHERE f_id = $1::text", - &[&id], - ) - .await - .expect("查用户失败"); - assert_eq!(rows[0]["deleteMark"], 1, "用户必须是软删"); - - // 角色关系被硬删。 - let rels = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text", - &[&id], - ) - .await - .expect("查角色关系失败"); - assert!(rels.is_empty(), "角色关系必须被硬删:{rels:?}"); - - // 幂等:再删一次仍成功。 - let again = sys::user_delete(State(state), headers, query(&format!("id={id}"))) - .await - .0; - assert_eq!(again.code, 200, "重复删除必须幂等成功"); -} - -// ---------------------------------------------------------------- 角色 - -/// 角色:空名 ⇒ `400 "角色名称不能为空"`。 -#[tokio::test] -async fn role_empty_full_name_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::role_save( - State(state), - headers, - Bytes::from(json!({"fullName": "", "enCode": "smoke_empty"}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "角色名称不能为空"); -} - -/// 角色:重复 `enCode` ⇒ `400 "角色编码已存在:smoke_dup_code"`。 -#[tokio::test] -async fn role_duplicate_en_code_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_role WHERE f_en_code = 'smoke_dup_code'") - .await - .expect("清理失败"); - - let first = sys::role_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "冒烟角色", "enCode": "smoke_dup_code"}).to_string()), - ) - .await - .0; - assert_eq!(first.code, 200, "第一次新建应成功:{}", first.msg); - - let second = sys::role_save( - State(state), - headers, - Bytes::from(json!({"fullName": "另一个", "enCode": "smoke_dup_code"}).to_string()), - ) - .await - .0; - assert_eq!(second.code, 400); - assert_eq!(second.msg, "角色编码已存在:smoke_dup_code"); -} - -/// 角色:更新不存在的 id ⇒ `400 "角色不存在"`。 -#[tokio::test] -async fn role_update_of_missing_id_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::role_save( - State(state), - headers, - Bytes::from( - json!({"id": "00000000-0000-4000-8000-000000000001", "fullName": "幽灵"}).to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "角色不存在"); -} - -/// 角色:新建 ⇒ `type` 缺省 `'user'`、`sortCode` 缺省 `0`、`creatorUserId = 'admin'`。 -#[tokio::test] -async fn role_save_defaults_follow_contract() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_role WHERE f_en_code = 'smoke_defaults'") - .await - .expect("清理失败"); - - let r = sys::role_save( - State(state), - headers, - Bytes::from(json!({"fullName": "默认角色", "enCode": "smoke_defaults"}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 200, "新建应成功:{}", r.msg); - let data = data_obj(&r); - assert_eq!(data["type"], "user", "type 缺省必须是 'user'"); - assert_eq!(data["sortCode"], 0, "sortCode 缺省必须是 0"); - assert_eq!(data["creatorUserId"], "admin"); - assert_eq!(data["deleteMark"], 0); - assert_eq!(data["id"].as_str().map(str::len), Some(36)); -} - -/// 角色:删除 ⇒ 角色软删、该角色的授权软删、角色关系硬删。 -#[tokio::test] -async fn role_delete_soft_deletes_role_and_authorizations() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_role WHERE f_en_code = 'smoke_del_role'") - .await - .expect("清理失败"); - let created = sys::role_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "待删角色", "enCode": "smoke_del_role"}).to_string()), - ) - .await - .0; - assert_eq!(created.code, 200); - let role_id = created.data["id"].as_str().expect("必须有 id").to_string(); - - // 给它一条授权 + 一条角色关系。 - let auth = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(role_id.clone()), - Bytes::from(json!({"objectType": "role", "module": ["m_demo"]}).to_string()), - ) - .await - .0; - assert_eq!(auth.code, 200); - - let r = sys::role_delete( - State(state.clone()), - headers.clone(), - query(&format!("id={role_id}")), - ) - .await - .0; - assert_eq!(r.code, 200); - - let roles = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_role WHERE f_id = $1::text", - &[&role_id], - ) - .await - .expect("查角色失败"); - assert_eq!(roles[0]["deleteMark"], 1, "角色必须软删"); - - let auths = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_authorize \ - WHERE f_object_type = 'role' AND f_object_id = $1::text", - &[&role_id], - ) - .await - .expect("查授权失败"); - assert!(!auths.is_empty(), "该角色的授权行应该还在(软删)"); - for a in &auths { - assert_eq!(a["deleteMark"], 1, "授权必须软删:{a}"); - } - - let rels = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role_relation WHERE f_role_id = $1::text", - &[&role_id], - ) - .await - .expect("查关系失败"); - assert!(rels.is_empty(), "角色关系必须被硬删:{rels:?}"); -} - -/// `GET /api/ssw/sys/Role/Modules?roleId=` ⇒ 该角色的菜单 id 数组。 -#[tokio::test] -async fn role_modules_returns_item_ids() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::role_modules( - State(state), - headers, - query("roleId=role_admin"), - ) - .await - .0; - assert_eq!(r.code, 200); - let ids = r.data.as_array().expect("必须返回数组"); - assert!(ids.iter().all(|v| v.is_string()), "必须是 string[]:{ids:?}"); - // 种子给 admin 角色授权了全部内置菜单。 - assert!(ids.contains(&json!("m_user")), "应包含 m_user:{ids:?}"); -} - -// ---------------------------------------------------------------- 机构 - -/// 机构:空名 ⇒ `400 "机构名称不能为空"`。 -#[tokio::test] -async fn organize_empty_full_name_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::organize_save( - State(state), - headers, - Bytes::from(json!({"fullName": ""}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "机构名称不能为空"); -} - -/// 机构:更新不存在的 id ⇒ `400 "机构不存在"`。 -#[tokio::test] -async fn organize_update_of_missing_id_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::organize_save( - State(state), - headers, - Bytes::from( - json!({"id": "00000000-0000-4000-8000-000000000002", "fullName": "幽灵机构"}) - .to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "机构不存在"); -} - -/// 机构:有子机构时 Delete ⇒ `400 "该机构下还有子机构,先删除子机构"`。 -#[tokio::test] -async fn organize_with_children_cannot_be_deleted() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_organize WHERE f_full_name IN ('smoke_org_parent', 'smoke_org_child')") - .await - .expect("清理失败"); - - let parent = sys::organize_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "smoke_org_parent"}).to_string()), - ) - .await - .0; - assert_eq!(parent.code, 200, "建父机构应成功:{}", parent.msg); - let parent_id = parent.data["id"].as_str().expect("必须有 id").to_string(); - - let child = sys::organize_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "smoke_org_child", "parentId": parent_id}).to_string()), - ) - .await - .0; - assert_eq!(child.code, 200, "建子机构应成功:{}", child.msg); - - let r = sys::organize_delete( - State(state.clone()), - headers.clone(), - query(&format!("id={parent_id}")), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "该机构下还有子机构,先删除子机构"); - - // 删掉子机构后,父机构就能删了。 - let child_id = child.data["id"].as_str().expect("必须有 id").to_string(); - let del_child = sys::organize_delete( - State(state.clone()), - headers.clone(), - query(&format!("id={child_id}")), - ) - .await - .0; - assert_eq!(del_child.code, 200); - - let del_parent = sys::organize_delete( - State(state), - headers, - query(&format!("id={parent_id}")), - ) - .await - .0; - assert_eq!(del_parent.code, 200, "没有子机构后必须能删"); -} - -/// 机构:新建 ⇒ `parentId` 缺省 `'0'`、**不写 `f_creator_user_id`**。 -#[tokio::test] -async fn organize_save_defaults_follow_contract() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_organize WHERE f_full_name = 'smoke_org_default'") - .await - .expect("清理失败"); - - let r = sys::organize_save( - State(state.clone()), - headers, - Bytes::from(json!({"fullName": "smoke_org_default"}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 200, "新建应成功:{}", r.msg); - let data = data_obj(&r); - assert_eq!(data["parentId"], "0", "parentId 缺省必须是 '0'"); - assert_eq!(data["sortCode"], 0); - assert_eq!(data["enabledMark"], 1); - - // 🔴 react 的 `base_organize` entity 没有 `f_creator_user_id` ⇒ 库里必须是 NULL。 - let org_id = data["id"].as_str().unwrap_or("").to_string(); - let rows = db - .query_json_params( - "SELECT f_creator_user_id AS \"creatorUserId\" FROM base_organize \ - WHERE f_id = $1::text", - &[&org_id], - ) - .await - .expect("查机构失败"); - assert!( - rows[0]["creatorUserId"].is_null(), - "机构不得写 f_creator_user_id:{}", - rows[0]["creatorUserId"] - ); -} - -// ---------------------------------------------------------------- 菜单 - -/// 菜单:空名 ⇒ `400 "菜单名称不能为空"`。 -#[tokio::test] -async fn module_empty_full_name_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::module_save( - State(state), - headers, - Bytes::from(json!({"fullName": ""}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "菜单名称不能为空"); -} - -/// 菜单:更新不存在的 id ⇒ `400 "菜单不存在"`。 -#[tokio::test] -async fn module_update_of_missing_id_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let r = sys::module_save( - State(state), - headers, - Bytes::from( - json!({"id": "00000000-0000-4000-8000-000000000003", "fullName": "幽灵菜单"}) - .to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 400); - assert_eq!(r.msg, "菜单不存在"); -} - -/// 菜单:新建 ⇒ `type` 缺省 **2**(INTEGER)、`parentId` 缺省 `'0'`。 -#[tokio::test] -async fn module_save_defaults_follow_contract() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_module WHERE f_full_name = 'smoke_menu_default'") - .await - .expect("清理失败"); - - let r = sys::module_save( - State(state.clone()), - headers, - Bytes::from(json!({"fullName": "smoke_menu_default"}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 200, "新建应成功:{}", r.msg); - let data = data_obj(&r); - assert_eq!(data["type"], 2, "type 缺省必须是 2(页面)"); - assert_eq!(data["parentId"], "0"); - assert_eq!(data["sortCode"], 0); -} - -/// 🔴 菜单更新时 **body 没有 `urlAddress` ⇒ 原值不动**(裁决 S16 的承重之处)。 -#[tokio::test] -async fn module_update_keeps_url_address_when_body_omits_it() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_module WHERE f_full_name = 'smoke_menu_url'") - .await - .expect("清理失败"); - - let created = sys::module_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"fullName": "smoke_menu_url", "urlAddress": "smoke/UrlKey"}).to_string(), - ), - ) - .await - .0; - assert_eq!(created.code, 200, "新建应成功:{}", created.msg); - let id = created.data["id"].as_str().expect("必须有 id").to_string(); - - // 只改名字,**不带 urlAddress**。 - let updated = sys::module_save( - State(state.clone()), - headers, - Bytes::from(json!({"id": id, "fullName": "smoke_menu_url_改名"}).to_string()), - ) - .await - .0; - assert_eq!(updated.code, 200, "更新应成功:{}", updated.msg); - assert_eq!( - updated.data["urlAddress"], "smoke/UrlKey", - "urlAddress 缺省时不得被清空(否则菜单变成未映射 ⇒ 静默越权)" - ); - - let rows = db - .query_json_params( - "SELECT f_url_address AS \"urlAddress\" FROM base_module WHERE f_id = $1::text", - &[&id], - ) - .await - .expect("查菜单失败"); - assert_eq!(rows[0]["urlAddress"], "smoke/UrlKey"); -} - -/// 菜单:删除 ⇒ 软删菜单 + 软删该菜单的授权行。 -#[tokio::test] -async fn module_delete_soft_deletes_menu_and_authorizations() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_module WHERE f_full_name = 'smoke_menu_del'") - .await - .expect("清理失败"); - let created = sys::module_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"fullName": "smoke_menu_del", "urlAddress": "smoke/DelKey"}).to_string(), - ), - ) - .await - .0; - assert_eq!(created.code, 200); - let module_id = created.data["id"].as_str().expect("必须有 id").to_string(); - - // 给它一条授权。 - let auth = sys::authority_data( - State(state.clone()), - headers.clone(), - Path("smoke_auth_obj".to_string()), - Bytes::from(json!({"objectType": "role", "module": [&module_id]}).to_string()), - ) - .await - .0; - assert_eq!(auth.code, 200); - - let r = sys::module_delete( - State(state.clone()), - headers.clone(), - query(&format!("id={module_id}")), - ) - .await - .0; - assert_eq!(r.code, 200); - - let menus = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_module WHERE f_id = $1::text", - &[&module_id], - ) - .await - .expect("查菜单失败"); - assert_eq!(menus[0]["deleteMark"], 1, "菜单必须软删"); - - let auths = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_authorize \ - WHERE f_item_type = 'module' AND f_item_id = $1::text", - &[&module_id], - ) - .await - .expect("查授权失败"); - assert!(!auths.is_empty(), "该菜单的授权行应该还在(软删)"); - for a in &auths { - assert_eq!(a["deleteMark"], 1, "授权必须软删:{a}"); - } -} - -// ---------------------------------------------------------------- 授权 - -/// 授权写入一维 ⇒ `code=200`;`RoleModules?roleId=` 返回 `["m_demo"]`。 -#[tokio::test] -async fn authority_write_one_dimensional_module_array() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let object_id = "smoke_auth_role"; - let r = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(object_id.to_string()), - Bytes::from(json!({"objectType": "role", "module": ["m_demo"]}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 200, "写授权应成功:{}", r.msg); - assert_eq!(r.data, Value::Null, "成功时 data 是 null"); - - let mods = sys::authority_role_modules( - State(state.clone()), - headers.clone(), - query(&format!("roleId={object_id}")), - ) - .await - .0; - assert_eq!(mods.code, 200); - assert_eq!(mods.data, json!(["m_demo"])); - - // `Role/Modules` 与 `Authority/RoleModules` 是同一份语义。 - let mods2 = sys::role_modules( - State(state), - headers, - query(&format!("roleId={object_id}")), - ) - .await - .0; - assert_eq!(mods2.data, json!(["m_demo"])); -} - -/// 授权写入二维(历史形态)⇒ `code=200`,展平后落库。 -#[tokio::test] -async fn authority_write_accepts_legacy_two_dimensional_array() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let object_id = "smoke_auth_role_2d"; - let r = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(object_id.to_string()), - Bytes::from(json!({"objectType": "role", "module": [["m_demo"], []]}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 200, "写授权应成功:{}", r.msg); - - let mods = sys::authority_role_modules( - State(state), - headers, - query(&format!("roleId={object_id}")), - ) - .await - .0; - assert_eq!(mods.data, json!(["m_demo"]), "二维形态必须展平后落库"); -} - -/// 授权写入 `objectType: "Role"`(大写)⇒ **仍然 `code=200`**(react 忽略该字段)。 -#[tokio::test] -async fn authority_write_ignores_object_type_case() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let object_id = "smoke_auth_role_case"; - let r = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(object_id.to_string()), - Bytes::from(json!({"objectType": "Role", "module": ["m_demo"]}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 200, "objectType 大写不得拒绝:{}", r.msg); - - // 落库的 `f_object_type` 恒为 `'role'`。 - let rows = db - .query_json_params( - "SELECT f_object_type AS \"objectType\" FROM base_authorize \ - WHERE f_object_id = $1::text AND f_item_type = 'module' AND f_delete_mark = 0", - &[&object_id], - ) - .await - .expect("查授权失败"); - assert!(!rows.is_empty(), "应该有授权行"); - for row in &rows { - assert_eq!(row["objectType"], "role"); - } -} - -/// 授权写入:旧行被**软删**、新行插入;空数组 ⇒ 只软删不插。 -#[tokio::test] -async fn authority_write_soft_deletes_old_rows() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - let object_id = "smoke_auth_soft"; - let first = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(object_id.to_string()), - Bytes::from(json!({"objectType": "role", "module": ["m_demo", "m_book"]}).to_string()), - ) - .await - .0; - assert_eq!(first.code, 200); - - // 换成另一个集合 ⇒ 旧行软删、新行插入。 - let second = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(object_id.to_string()), - Bytes::from(json!({"objectType": "role", "module": ["m_user"]}).to_string()), - ) - .await - .0; - assert_eq!(second.code, 200); - - let live = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_id = $1::text AND f_delete_mark = 0 AND f_item_type = 'module'", - &[&object_id], - ) - .await - .expect("查授权失败"); - let live_ids: Vec<&str> = live - .iter() - .filter_map(|r| r["itemId"].as_str()) - .collect(); - assert_eq!(live_ids, vec!["m_user"], "活着的授权只剩新集合"); - - let dead = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_id = $1::text AND f_delete_mark = 1", - &[&object_id], - ) - .await - .expect("查授权失败"); - assert_eq!(dead.len(), 2, "旧的两行必须被软删而不是物理删除"); - - // 空数组 ⇒ 只软删不插。 - let third = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(object_id.to_string()), - Bytes::from(json!({"objectType": "role", "module": []}).to_string()), - ) - .await - .0; - assert_eq!(third.code, 200); - - let after = sys::authority_role_modules( - State(state), - headers, - query(&format!("roleId={object_id}")), - ) - .await - .0; - assert_eq!(after.data, json!([]), "空数组必须把授权清空"); -} - -// ---------------------------------------------------------------- 守卫 - -/// 未登录访问 5 组端点 ⇒ `code=600`;授权端点也是 `600`。 -#[tokio::test] -async fn guards_reject_anonymous_requests() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - let anon = anon_headers(); - - let r = sys::user_list(State(state.clone()), anon.clone()).await.0; - assert_eq!(r.code, 600, "未登录必须是 code=600"); - assert_eq!(r.msg, "未登录"); - - let r = sys::role_list(State(state.clone()), anon.clone()).await.0; - assert_eq!(r.code, 600); - - let r = sys::organize_list(State(state.clone()), anon.clone()).await.0; - assert_eq!(r.code, 600); - - let r = sys::module_list(State(state.clone()), anon.clone()).await.0; - assert_eq!(r.code, 600); - - let r = sys::role_modules(State(state.clone()), anon.clone(), query("roleId=role_admin")) - .await - .0; - assert_eq!(r.code, 600, "Role/Modules 是仅登录守卫"); - - let r = sys::authority_role_modules(State(state.clone()), anon.clone(), query("roleId=x")) - .await - .0; - assert_eq!(r.code, 600); - - let r = sys::authority_data( - State(state), - anon, - Path("x".to_string()), - Bytes::from(json!({"module": []}).to_string()), - ) - .await - .0; - assert_eq!(r.code, 600); -} - -/// 非管理员没有 `system/User` 菜单 ⇒ `code=403`。 -#[tokio::test] -async fn menu_guard_rejects_non_admin_without_permission() { - let db = db().await; - let _guard = LOCK.lock().await; - let state = new_state(db); - // 造一个非管理员用户(不给任何授权)。 - let token = state.sessions.issue("smoke_plain", "smoke_plain_id", 0); - let headers = auth_headers(&token); - - let r = sys::user_list(State(state), headers).await.0; - assert_eq!(r.code, 403, "无菜单权限必须是 code=403"); - assert_eq!(r.msg, "无菜单权限"); -} - -// ---------------------------------------------------------------- 修复轮 R=1:Delete 的 `id` 缺失不得误伤数据 - -/// 🔴 User Delete:`id` 缺失 / 为空 ⇒ `code=200` **且哨兵行 `f_delete_mark` 仍是 0**。 -/// -/// 钉住 Ruling P62 的安全前置条件:「`id` 缺失时绝不能退化成『无 WHERE 条件的全表更新』」。 -#[tokio::test] -async fn user_delete_without_id_keeps_sentinel_row() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - // ---- 哨兵行(自造自清)---- - db.exec("DELETE FROM base_user WHERE f_account = 'it-del-guard-user'") - .await - .expect("清理失败"); - let sentinel = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"account": "it-del-guard-user"}).to_string()), - ) - .await - .0; - assert_eq!(sentinel.code, 200, "造哨兵行失败:{}", sentinel.msg); - let sid = sentinel.data["id"].as_str().expect("必须有 id").to_string(); - - // ---- query 完全没有(`RawQuery(None)`)---- - let r = sys::user_delete(State(state.clone()), headers.clone(), query_none()).await.0; - assert_eq!(r.code, 200, "id 缺失必须幂等成功"); - // ---- query 是 `id=`(空值)---- - let r = sys::user_delete(State(state.clone()), headers.clone(), query("id=")).await.0; - assert_eq!(r.code, 200, "id 为空必须幂等成功"); - - // ---- 🔴 关键断言:哨兵行没被误删 ---- - let rows = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_user WHERE f_id = $1::text", - &[&sid], - ) - .await - .expect("查哨兵失败"); - assert_eq!(rows.len(), 1, "哨兵行不该消失"); - assert_eq!( - rows[0]["deleteMark"], 0, - "id 缺失时不得退化成全表更新(哨兵被误删)" - ); - - // ---- 自清 ---- - db.exec_params( - "DELETE FROM base_user WHERE f_id = $1::text", - &[&sid], - ) - .await - .expect("自清失败"); -} - -/// 🔴 Role Delete:`id` 缺失 / 为空 ⇒ `code=200`,哨兵角色与其授权行都仍是 `f_delete_mark = 0`。 -#[tokio::test] -async fn role_delete_without_id_keeps_sentinel_row() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_role WHERE f_en_code = 'it-del-guard-role'") - .await - .expect("清理失败"); - let sentinel = sys::role_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "哨兵角色", "enCode": "it-del-guard-role"}).to_string()), - ) - .await - .0; - assert_eq!(sentinel.code, 200, "造哨兵行失败:{}", sentinel.msg); - let sid = sentinel.data["id"].as_str().expect("必须有 id").to_string(); - - // 给哨兵一条授权(Role Delete 还会软删 `base_authorize`)。 - let auth = sys::authority_data( - State(state.clone()), - headers.clone(), - Path(sid.clone()), - Bytes::from(json!({"objectType": "role", "module": ["m_demo"]}).to_string()), - ) - .await - .0; - assert_eq!(auth.code, 200); - - let r = sys::role_delete(State(state.clone()), headers.clone(), query_none()).await.0; - assert_eq!(r.code, 200, "id 缺失必须幂等成功"); - let r = sys::role_delete(State(state.clone()), headers.clone(), query("id=")).await.0; - assert_eq!(r.code, 200, "id 为空必须幂等成功"); - - let rows = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_role WHERE f_id = $1::text", - &[&sid], - ) - .await - .expect("查哨兵失败"); - assert_eq!(rows.len(), 1, "哨兵行不该消失"); - assert_eq!(rows[0]["deleteMark"], 0, "哨兵角色被误删了"); - - let auths = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_authorize \ - WHERE f_object_type = 'role' AND f_object_id = $1::text", - &[&sid], - ) - .await - .expect("查哨兵授权失败"); - assert!(!auths.is_empty(), "哨兵授权不该消失"); - for a in &auths { - assert_eq!(a["deleteMark"], 0, "哨兵授权被误软删了"); - } - - db.exec_params( - "DELETE FROM base_authorize WHERE f_object_id = $1::text AND f_object_type = 'role'", - &[&sid], - ) - .await - .expect("自清失败"); - db.exec_params("DELETE FROM base_role WHERE f_id = $1::text", &[&sid]) - .await - .expect("自清失败"); -} - -/// 🔴 Organize Delete:`id` 缺失 / 为空 ⇒ `code=200`,哨兵机构仍是 `f_delete_mark = 0`。 -#[tokio::test] -async fn organize_delete_without_id_keeps_sentinel_row() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_organize WHERE f_full_name = 'it-del-guard-org'") - .await - .expect("清理失败"); - let sentinel = sys::organize_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "it-del-guard-org"}).to_string()), - ) - .await - .0; - assert_eq!(sentinel.code, 200, "造哨兵行失败:{}", sentinel.msg); - let sid = sentinel.data["id"].as_str().expect("必须有 id").to_string(); - - let r = sys::organize_delete(State(state.clone()), headers.clone(), query_none()).await.0; - assert_eq!(r.code, 200, "id 缺失必须幂等成功"); - let r = sys::organize_delete(State(state.clone()), headers.clone(), query("id=")).await.0; - assert_eq!(r.code, 200, "id 为空必须幂等成功"); - - let rows = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_organize WHERE f_id = $1::text", - &[&sid], - ) - .await - .expect("查哨兵失败"); - assert_eq!(rows.len(), 1, "哨兵行不该消失"); - assert_eq!(rows[0]["deleteMark"], 0, "哨兵机构被误删了"); - - db.exec_params("DELETE FROM base_organize WHERE f_id = $1::text", &[&sid]) - .await - .expect("自清失败"); -} - -/// 🔴 Module Delete:`id` 缺失 / 为空 ⇒ `code=200`,哨兵菜单与其授权行都仍是 `f_delete_mark = 0`。 -#[tokio::test] -async fn module_delete_without_id_keeps_sentinel_row() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_module WHERE f_full_name = 'it-del-guard-menu'") - .await - .expect("清理失败"); - let sentinel = sys::module_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "it-del-guard-menu"}).to_string()), - ) - .await - .0; - assert_eq!(sentinel.code, 200, "造哨兵行失败:{}", sentinel.msg); - let sid = sentinel.data["id"].as_str().expect("必须有 id").to_string(); - - // 给哨兵一条授权(Module Delete 还会软删 `base_authorize`)。 - let auth = sys::authority_data( - State(state.clone()), - headers.clone(), - Path("it-del-guard-auth-obj".to_string()), - Bytes::from(json!({"objectType": "role", "module": [&sid]}).to_string()), - ) - .await - .0; - assert_eq!(auth.code, 200); - - let r = sys::module_delete(State(state.clone()), headers.clone(), query_none()).await.0; - assert_eq!(r.code, 200, "id 缺失必须幂等成功"); - let r = sys::module_delete(State(state.clone()), headers.clone(), query("id=")).await.0; - assert_eq!(r.code, 200, "id 为空必须幂等成功"); - - let rows = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_module WHERE f_id = $1::text", - &[&sid], - ) - .await - .expect("查哨兵失败"); - assert_eq!(rows.len(), 1, "哨兵行不该消失"); - assert_eq!(rows[0]["deleteMark"], 0, "哨兵菜单被误删了"); - - let auths = db - .query_json_params( - "SELECT f_delete_mark AS \"deleteMark\" FROM base_authorize \ - WHERE f_item_type = 'module' AND f_item_id = $1::text", - &[&sid], - ) - .await - .expect("查哨兵授权失败"); - assert!(!auths.is_empty(), "哨兵授权不该消失"); - for a in &auths { - assert_eq!(a["deleteMark"], 0, "哨兵授权被误软删了"); - } - - db.exec_params( - "DELETE FROM base_authorize WHERE f_item_id = $1::text AND f_item_type = 'module'", - &[&sid], - ) - .await - .expect("自清失败"); - db.exec_params("DELETE FROM base_module WHERE f_id = $1::text", &[&sid]) - .await - .expect("自清失败"); -} - -// ---------------------------------------------------------------- 修复轮 R=1:契约里带 ⚠️ 的几条规则 - -/// 契约 §7.1 第 2+4 条:更新时账号**被别的用户占用** ⇒ `400 '账号已存在:'`。 -#[tokio::test] -async fn user_update_with_account_owned_by_another_user_is_rejected() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec( - "DELETE FROM base_user WHERE f_account IN ('it-dup-owner', 'it-dup-other')", - ) - .await - .expect("清理失败"); - - let owner = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"account": "it-dup-owner"}).to_string()), - ) - .await - .0; - assert_eq!(owner.code, 200, "造占用者失败:{}", owner.msg); - let other = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"account": "it-dup-other"}).to_string()), - ) - .await - .0; - assert_eq!(other.code, 200, "造另一个用户失败:{}", other.msg); - let other_id = other.data["id"].as_str().expect("必须有 id").to_string(); - - // 把「另一个用户」的账号改成「占用者」的账号 ⇒ 必须被拒。 - let r = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"id": other_id, "account": "it-dup-owner", "realName": "撞号"}).to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 400, "账号被别人占用时必须是 code=400"); - assert_eq!(r.msg, "账号已存在:it-dup-owner"); - - // 被拒的那个用户**原账号不变**。 - let rows = db - .query_json_params( - "SELECT f_account AS \"account\" FROM base_user WHERE f_id = $1::text", - &[&other_id], - ) - .await - .expect("查用户失败"); - assert_eq!(rows[0]["account"], "it-dup-other", "被拒的更新不得落库"); - - db.exec("DELETE FROM base_user WHERE f_account IN ('it-dup-owner', 'it-dup-other')") - .await - .expect("自清失败"); -} - -/// 契约 §7.1 第 2 条:查重条件是 `f_account = ? AND f_delete_mark = 0` -/// ⇒ **软删掉的同名账号可以重建**(拿到新的 id)。 -#[tokio::test] -async fn soft_deleted_account_can_be_recreated() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'it-recreate'") - .await - .expect("清理失败"); - - let first = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"account": "it-recreate"}).to_string()), - ) - .await - .0; - assert_eq!(first.code, 200, "第一次新建应成功:{}", first.msg); - let first_id = first.data["id"].as_str().expect("必须有 id").to_string(); - - // 软删它。 - let del = sys::user_delete( - State(state.clone()), - headers.clone(), - query(&format!("id={first_id}")), - ) - .await - .0; - assert_eq!(del.code, 200); - - // 同名重建 ⇒ 必须成功,且是**新的 id**。 - let second = sys::user_save( - State(state.clone()), - headers, - Bytes::from(json!({"account": "it-recreate"}).to_string()), - ) - .await - .0; - assert_eq!(second.code, 200, "软删的账号必须可以重建:{}", second.msg); - let second_id = second.data["id"].as_str().expect("必须有 id").to_string(); - assert_ne!(second_id, first_id, "重建必须拿到新的 id"); - - db.exec("DELETE FROM base_user WHERE f_account = 'it-recreate'") - .await - .expect("自清失败"); -} - -/// 契约 §7.1 / §7.2 / §7.4 的 ⚠️ 条目:更新**不碰**那些列。 -/// -/// - User 更新:不碰 `f_creator_time` / `f_enabled_mark` / `f_delete_mark`; -/// - Role 更新:不碰 `f_sort_code` / `f_enabled_mark`;body 没有 `type` ⇒ `f_type` 保留原值; -/// - Module 更新:body 没有 `type` ⇒ `f_type` 保留原值。 -/// (⚠️ Module 的 `f_sort_code` 更新时**是要**覆盖成 0 的 ⇒ 这里不断言它不变。) -#[tokio::test] -async fn update_keeps_contract_protected_columns() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - // ================= User ================= - db.exec("DELETE FROM base_user WHERE f_account = 'it-keep-user'") - .await - .expect("清理失败"); - let user = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"account": "it-keep-user"}).to_string()), - ) - .await - .0; - assert_eq!(user.code, 200, "造用户失败:{}", user.msg); - let uid = user.data["id"].as_str().expect("必须有 id").to_string(); - - let before = db - .query_json_params( - "SELECT f_creator_time::text AS \"creatorTime\", f_enabled_mark AS \"enabledMark\", \ - f_delete_mark AS \"deleteMark\" \ - FROM base_user WHERE f_id = $1::text", - &[&uid], - ) - .await - .expect("查用户失败"); - let before = before[0].clone(); - - let updated = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"id": uid, "account": "it-keep-user", "realName": "改名"}).to_string()), - ) - .await - .0; - assert_eq!(updated.code, 200, "更新应成功:{}", updated.msg); - - let after = db - .query_json_params( - "SELECT f_creator_time::text AS \"creatorTime\", f_enabled_mark AS \"enabledMark\", \ - f_delete_mark AS \"deleteMark\" \ - FROM base_user WHERE f_id = $1::text", - &[&uid], - ) - .await - .expect("查用户失败"); - let after = after[0].clone(); - assert_eq!( - after["creatorTime"], before["creatorTime"], - "User 更新不得碰 f_creator_time" - ); - assert_eq!( - after["enabledMark"], before["enabledMark"], - "User 更新不得碰 f_enabled_mark" - ); - assert_eq!( - after["deleteMark"], before["deleteMark"], - "User 更新不得碰 f_delete_mark" - ); - - // ================= Role ================= - db.exec("DELETE FROM base_role WHERE f_en_code = 'it-keep-role'") - .await - .expect("清理失败"); - let role = sys::role_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"fullName": "哨兵角色", "enCode": "it-keep-role", "sortCode": 42}).to_string(), - ), - ) - .await - .0; - assert_eq!(role.code, 200, "造角色失败:{}", role.msg); - let rid = role.data["id"].as_str().expect("必须有 id").to_string(); - - let role_before = db - .query_json_params( - "SELECT f_sort_code AS \"sortCode\", f_enabled_mark AS \"enabledMark\", \ - f_type AS \"type\" FROM base_role WHERE f_id = $1::text", - &[&rid], - ) - .await - .expect("查角色失败"); - let role_before = role_before[0].clone(); - assert_eq!(role_before["sortCode"], 42, "前置:sortCode 应是 42"); - assert_eq!(role_before["type"], "user", "前置:type 缺省应是 'user'"); - - // 🔴 body **不带** `type` ⇒ `f_type` 保留原值。 - let role_updated = sys::role_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"id": rid, "fullName": "角色改名"}).to_string()), - ) - .await - .0; - assert_eq!(role_updated.code, 200, "更新应成功:{}", role_updated.msg); - - let role_after = db - .query_json_params( - "SELECT f_sort_code AS \"sortCode\", f_enabled_mark AS \"enabledMark\", \ - f_type AS \"type\" FROM base_role WHERE f_id = $1::text", - &[&rid], - ) - .await - .expect("查角色失败"); - let role_after = role_after[0].clone(); - assert_eq!( - role_after["sortCode"], role_before["sortCode"], - "Role 更新不得碰 f_sort_code" - ); - assert_eq!( - role_after["enabledMark"], role_before["enabledMark"], - "Role 更新不得碰 f_enabled_mark" - ); - assert_eq!( - role_after["type"], role_before["type"], - "body 缺 type 时 f_type 必须保留原值" - ); - - // ================= Module ================= - db.exec("DELETE FROM base_module WHERE f_full_name = 'it-keep-menu'") - .await - .expect("清理失败"); - let menu = sys::module_save( - State(state.clone()), - headers.clone(), - Bytes::from(json!({"fullName": "it-keep-menu", "type": 1}).to_string()), - ) - .await - .0; - assert_eq!(menu.code, 200, "造菜单失败:{}", menu.msg); - let mid = menu.data["id"].as_str().expect("必须有 id").to_string(); - - let menu_before = db - .query_json_params( - "SELECT f_type AS \"type\" FROM base_module WHERE f_id = $1::text", - &[&mid], - ) - .await - .expect("查菜单失败"); - let menu_before = menu_before[0].clone(); - assert_eq!(menu_before["type"], 1, "前置:type 应是 1(目录)"); - - // 🔴 body **不带** `type` ⇒ `f_type` 保留原值。 - let menu_updated = sys::module_save( - State(state), - headers, - Bytes::from(json!({"id": mid, "fullName": "it-keep-menu-改名"}).to_string()), - ) - .await - .0; - assert_eq!(menu_updated.code, 200, "更新应成功:{}", menu_updated.msg); - - let menu_after = db - .query_json_params( - "SELECT f_type AS \"type\" FROM base_module WHERE f_id = $1::text", - &[&mid], - ) - .await - .expect("查菜单失败"); - assert_eq!( - menu_after[0]["type"], menu_before["type"], - "body 缺 type 时 f_type 必须保留原值" - ); - - // ---- 自清 ---- - db.exec("DELETE FROM base_user WHERE f_account = 'it-keep-user'") - .await - .expect("自清失败"); - db.exec("DELETE FROM base_role WHERE f_en_code = 'it-keep-role'") - .await - .expect("自清失败"); - db.exec("DELETE FROM base_module WHERE f_full_name IN ('it-keep-menu', 'it-keep-menu-改名')") - .await - .expect("自清失败"); -} - -// ---------------------------------------------------------------- 修复轮 R=2:两个相邻分支的钉子 - -/// 查某用户的角色关系行数(🔴 务必带 `f_object_type='user' AND f_object_id=` 条件, -/// 不能按整表统计 —— 别的测试的行会污染计数)。 -async fn count_user_roles(db: &Db, user_id: &str) -> i64 { - let rows = db - .query_json_params( - "SELECT count(*) AS \"n\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text", - &[&user_id], - ) - .await - .expect("count 失败"); - rows.first() - .and_then(|r| r.get("n")) - .and_then(Value::as_i64) - .expect("count(*) 恒有一行") -} - -/// 查某用户的角色 id 列表(排序后返回,避免行序影响比较)。 -async fn user_role_ids(db: &Db, user_id: &str) -> Vec { - let rows = db - .query_json_params( - "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text", - &[&user_id], - ) - .await - .expect("查角色关系失败"); - let mut ids: Vec = rows - .iter() - .filter_map(|r| r.get("roleId").and_then(Value::as_str)) - .map(str::to_string) - .collect(); - ids.sort(); - ids -} - -/// 🔴 **契约分支**(契约 §7.1 第 5 条):`roleIds: []` ⇒ **只删不插** -/// ⇒ 该用户的 `base_role_relation` 行数 **== 0**(旧行被硬删、没插新的)。 -/// -/// (与下一条「全非法数组 ⇒ 一行不动」**结果完全相反**,两条必须同时钉住。) -#[tokio::test] -async fn user_save_with_empty_role_ids_clears_role_relations() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'it-roleids-empty-user'") - .await - .expect("清理失败"); - - // 造一个挂了 2 个角色的用户。 - let created = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({ - "account": "it-roleids-empty-user", - "roleIds": ["role_admin", "role_user"] - }) - .to_string(), - ), - ) - .await - .0; - assert_eq!(created.code, 200, "造用户失败:{}", created.msg); - let uid = created.data["id"].as_str().expect("必须有 id").to_string(); - assert_eq!( - count_user_roles(db, &uid).await, - 2, - "前置:应当挂了 2 个角色" - ); - - // `roleIds: []` ⇒ 只删不插。 - let r = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"id": uid, "account": "it-roleids-empty-user", "roleIds": []}).to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 200, "空 roleIds 应成功:{}", r.msg); - - // 🔴 关键断言:旧行被硬删、没插新的 ⇒ 行数 == 0。 - assert_eq!( - count_user_roles(db, &uid).await, - 0, - "roleIds: [] 必须清空该用户的关系行(只删不插)" - ); - - // ---- 自清 ---- - db.exec_params( - "DELETE FROM base_role_relation WHERE f_object_type = 'user' AND f_object_id = $1::text", - &[&uid], - ) - .await - .expect("自清失败"); - db.exec("DELETE FROM base_user WHERE f_account = 'it-roleids-empty-user'") - .await - .expect("自清失败"); -} - -/// 🔴 **早退分支**(R=1 必改 3 引入):`roleIds: [123]`(非空、全非法) -/// ⇒ 该用户的 `base_role_relation` 行数 **仍然是 2**,且两条 `f_role_id` **都没变**。 -/// -/// (与上一条「`roleIds: []` ⇒ 清空」**结果完全相反**,两条必须同时钉住。) -#[tokio::test] -async fn user_save_with_all_invalid_role_ids_keeps_role_relations() { - let db = db().await; - let _guard = LOCK.lock().await; - let (state, headers) = admin_state(db).await; - - db.exec("DELETE FROM base_user WHERE f_account = 'it-roleids-bad-user'") - .await - .expect("清理失败"); - - // 造一个挂了 2 个角色的用户。 - let created = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({ - "account": "it-roleids-bad-user", - "roleIds": ["role_admin", "role_user"] - }) - .to_string(), - ), - ) - .await - .0; - assert_eq!(created.code, 200, "造用户失败:{}", created.msg); - let uid = created.data["id"].as_str().expect("必须有 id").to_string(); - let before = user_role_ids(db, &uid).await; - assert_eq!(before.len(), 2, "前置:应当挂了 2 个角色:{before:?}"); - - // `roleIds: [123]`(非空、全非法)⇒ 关系行**一行不动**。 - let r = sys::user_save( - State(state.clone()), - headers.clone(), - Bytes::from( - json!({"id": uid, "account": "it-roleids-bad-user", "roleIds": [123]}).to_string(), - ), - ) - .await - .0; - assert_eq!(r.code, 200, "全非法 roleIds 不该报错:{}", r.msg); - - // 🔴 关键断言:行数仍是 2,且两条 `f_role_id` 都没变。 - assert_eq!( - count_user_roles(db, &uid).await, - 2, - "全非法 roleIds 不得清空已有角色关系" - ); - let after = user_role_ids(db, &uid).await; - assert_eq!(after, before, "全非法 roleIds 不得改动任何 f_role_id"); - - // ---- 自清 ---- - db.exec_params( - "DELETE FROM base_role_relation WHERE f_object_type = 'user' AND f_object_id = $1::text", - &[&uid], - ) - .await - .expect("自清失败"); - db.exec("DELETE FROM base_user WHERE f_account = 'it-roleids-bad-user'") - .await - .expect("自清失败"); -} diff --git a/src/frontend/dist/assets/index-BUfssMhg.js b/src/frontend/dist/assets/index-BUfssMhg.js new file mode 100644 index 0000000..0080e94 --- /dev/null +++ b/src/frontend/dist/assets/index-BUfssMhg.js @@ -0,0 +1,88 @@ +function Rp(e,t){for(var n=0;nr[o]})}}}return Object.freeze(Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}))}(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const o of document.querySelectorAll('link[rel="modulepreload"]'))r(o);new MutationObserver(o=>{for(const i of o)if(i.type==="childList")for(const l of i.addedNodes)l.tagName==="LINK"&&l.rel==="modulepreload"&&r(l)}).observe(document,{childList:!0,subtree:!0});function n(o){const i={};return o.integrity&&(i.integrity=o.integrity),o.referrerPolicy&&(i.referrerPolicy=o.referrerPolicy),o.crossOrigin==="use-credentials"?i.credentials="include":o.crossOrigin==="anonymous"?i.credentials="omit":i.credentials="same-origin",i}function r(o){if(o.ep)return;o.ep=!0;const i=n(o);fetch(o.href,i)}})();var X=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function lf(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}function Pp(e){if(e.__esModule)return e;var t=e.default;if(typeof t=="function"){var n=function r(){return this instanceof r?Reflect.construct(t,arguments,this.constructor):t.apply(this,arguments)};n.prototype=t.prototype}else n={};return Object.defineProperty(n,"__esModule",{value:!0}),Object.keys(e).forEach(function(r){var o=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(n,r,o.get?o:{enumerable:!0,get:function(){return e[r]}})}),n}var sf={exports:{}},zi={},af={exports:{}},Y={};/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var go=Symbol.for("react.element"),Op=Symbol.for("react.portal"),jp=Symbol.for("react.fragment"),Np=Symbol.for("react.strict_mode"),Tp=Symbol.for("react.profiler"),Lp=Symbol.for("react.provider"),zp=Symbol.for("react.context"),bp=Symbol.for("react.forward_ref"),Ip=Symbol.for("react.suspense"),Up=Symbol.for("react.memo"),Hp=Symbol.for("react.lazy"),La=Symbol.iterator;function Mp(e){return e===null||typeof e!="object"?null:(e=La&&e[La]||e["@@iterator"],typeof e=="function"?e:null)}var uf={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},cf=Object.assign,ff={};function vr(e,t,n){this.props=e,this.context=t,this.refs=ff,this.updater=n||uf}vr.prototype.isReactComponent={};vr.prototype.setState=function(e,t){if(typeof e!="object"&&typeof e!="function"&&e!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,e,t,"setState")};vr.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,"forceUpdate")};function df(){}df.prototype=vr.prototype;function ys(e,t,n){this.props=e,this.context=t,this.refs=ff,this.updater=n||uf}var gs=ys.prototype=new df;gs.constructor=ys;cf(gs,vr.prototype);gs.isPureReactComponent=!0;var za=Array.isArray,xf=Object.prototype.hasOwnProperty,Es={current:null},pf={key:!0,ref:!0,__self:!0,__source:!0};function hf(e,t,n){var r,o={},i=null,l=null;if(t!=null)for(r in t.ref!==void 0&&(l=t.ref),t.key!==void 0&&(i=""+t.key),t)xf.call(t,r)&&!pf.hasOwnProperty(r)&&(o[r]=t[r]);var s=arguments.length-2;if(s===1)o.children=n;else if(1>>1,R=L[k];if(0>>1;ko(ee,H))Go(K,ee)?(L[k]=K,L[G]=H,k=G):(L[k]=ee,L[O]=H,k=O);else if(Go(K,H))L[k]=K,L[G]=H,k=G;else break e}}return U}function o(L,U){var H=L.sortIndex-U.sortIndex;return H!==0?H:L.id-U.id}if(typeof performance=="object"&&typeof performance.now=="function"){var i=performance;e.unstable_now=function(){return i.now()}}else{var l=Date,s=l.now();e.unstable_now=function(){return l.now()-s}}var a=[],u=[],f=1,d=null,x=3,m=!1,y=!1,g=!1,E=typeof setTimeout=="function"?setTimeout:null,p=typeof clearTimeout=="function"?clearTimeout:null,c=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function h(L){for(var U=n(u);U!==null;){if(U.callback===null)r(u);else if(U.startTime<=L)r(u),U.sortIndex=U.expirationTime,t(a,U);else break;U=n(u)}}function v(L){if(g=!1,h(L),!y)if(n(a)!==null)y=!0,Q(w);else{var U=n(u);U!==null&&Z(v,U.startTime-L)}}function w(L,U){y=!1,g&&(g=!1,p(D),D=-1),m=!0;var H=x;try{for(h(U),d=n(a);d!==null&&(!(d.expirationTime>U)||L&&!F());){var k=d.callback;if(typeof k=="function"){d.callback=null,x=d.priorityLevel;var R=k(d.expirationTime<=U);U=e.unstable_now(),typeof R=="function"?d.callback=R:d===n(a)&&r(a),h(U)}else r(a);d=n(a)}if(d!==null)var T=!0;else{var O=n(u);O!==null&&Z(v,O.startTime-U),T=!1}return T}finally{d=null,x=H,m=!1}}var B=!1,S=null,D=-1,P=5,A=-1;function F(){return!(e.unstable_now()-AL||125k?(L.sortIndex=H,t(u,L),n(a)===null&&L===n(u)&&(g?(p(D),D=-1):g=!0,Z(v,H-k))):(L.sortIndex=R,t(a,L),y||m||(y=!0,Q(w))),L},e.unstable_shouldYield=F,e.unstable_wrapCallback=function(L){var U=x;return function(){var H=x;x=U;try{return L.apply(this,arguments)}finally{x=H}}}})(Cf);Ef.exports=Cf;var eh=Ef.exports;/** + * @license React + * react-dom.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var th=z,rt=eh;function b(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),El=Object.prototype.hasOwnProperty,nh=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,Ia={},Ua={};function rh(e){return El.call(Ua,e)?!0:El.call(Ia,e)?!1:nh.test(e)?Ua[e]=!0:(Ia[e]=!0,!1)}function oh(e,t,n,r){if(n!==null&&n.type===0)return!1;switch(typeof t){case"function":case"symbol":return!0;case"boolean":return r?!1:n!==null?!n.acceptsBooleans:(e=e.toLowerCase().slice(0,5),e!=="data-"&&e!=="aria-");default:return!1}}function ih(e,t,n,r){if(t===null||typeof t>"u"||oh(e,t,n,r))return!0;if(r)return!1;if(n!==null)switch(n.type){case 3:return!t;case 4:return t===!1;case 5:return isNaN(t);case 6:return isNaN(t)||1>t}return!1}function We(e,t,n,r,o,i,l){this.acceptsBooleans=t===2||t===3||t===4,this.attributeName=r,this.attributeNamespace=o,this.mustUseProperty=n,this.propertyName=e,this.type=t,this.sanitizeURL=i,this.removeEmptyString=l}var Oe={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(e){Oe[e]=new We(e,0,!1,e,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(e){var t=e[0];Oe[t]=new We(t,1,!1,e[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(e){Oe[e]=new We(e,2,!1,e.toLowerCase(),null,!1,!1)});["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(e){Oe[e]=new We(e,2,!1,e,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(e){Oe[e]=new We(e,3,!1,e.toLowerCase(),null,!1,!1)});["checked","multiple","muted","selected"].forEach(function(e){Oe[e]=new We(e,3,!0,e,null,!1,!1)});["capture","download"].forEach(function(e){Oe[e]=new We(e,4,!1,e,null,!1,!1)});["cols","rows","size","span"].forEach(function(e){Oe[e]=new We(e,6,!1,e,null,!1,!1)});["rowSpan","start"].forEach(function(e){Oe[e]=new We(e,5,!1,e.toLowerCase(),null,!1,!1)});var ws=/[\-:]([a-z])/g;function Bs(e){return e[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(e){var t=e.replace(ws,Bs);Oe[t]=new We(t,1,!1,e,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(e){var t=e.replace(ws,Bs);Oe[t]=new We(t,1,!1,e,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(e){var t=e.replace(ws,Bs);Oe[t]=new We(t,1,!1,e,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(e){Oe[e]=new We(e,1,!1,e.toLowerCase(),null,!1,!1)});Oe.xlinkHref=new We("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(e){Oe[e]=new We(e,1,!1,e.toLowerCase(),null,!0,!0)});function Ss(e,t,n,r){var o=Oe.hasOwnProperty(t)?Oe[t]:null;(o!==null?o.type!==0:r||!(2s||o[l]!==i[s]){var a=` +`+o[l].replace(" at new "," at ");return e.displayName&&a.includes("")&&(a=a.replace("",e.displayName)),a}while(1<=l&&0<=s);break}}}finally{l0=!1,Error.prepareStackTrace=n}return(e=e?e.displayName||e.name:"")?br(e):""}function lh(e){switch(e.tag){case 5:return br(e.type);case 16:return br("Lazy");case 13:return br("Suspense");case 19:return br("SuspenseList");case 0:case 2:case 15:return e=s0(e.type,!1),e;case 11:return e=s0(e.type.render,!1),e;case 1:return e=s0(e.type,!0),e;default:return""}}function Sl(e){if(e==null)return null;if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case Vn:return"Fragment";case qn:return"Portal";case Cl:return"Profiler";case As:return"StrictMode";case wl:return"Suspense";case Bl:return"SuspenseList"}if(typeof e=="object")switch(e.$$typeof){case Sf:return(e.displayName||"Context")+".Consumer";case Bf:return(e._context.displayName||"Context")+".Provider";case _s:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case Ds:return t=e.displayName||null,t!==null?t:Sl(e.type)||"Memo";case Vt:t=e._payload,e=e._init;try{return Sl(e(t))}catch{}}return null}function sh(e){var t=e.type;switch(e.tag){case 24:return"Cache";case 9:return(t.displayName||"Context")+".Consumer";case 10:return(t._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=t.render,e=e.displayName||e.name||"",t.displayName||(e!==""?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return t;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return Sl(t);case 8:return t===As?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof t=="function")return t.displayName||t.name||null;if(typeof t=="string")return t}return null}function an(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function _f(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function ah(e){var t=_f(e)?"checked":"value",n=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),r=""+e[t];if(!e.hasOwnProperty(t)&&typeof n<"u"&&typeof n.get=="function"&&typeof n.set=="function"){var o=n.get,i=n.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return o.call(this)},set:function(l){r=""+l,i.call(this,l)}}),Object.defineProperty(e,t,{enumerable:n.enumerable}),{getValue:function(){return r},setValue:function(l){r=""+l},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function jo(e){e._valueTracker||(e._valueTracker=ah(e))}function Df(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var n=t.getValue(),r="";return e&&(r=_f(e)?e.checked?"true":"false":e.value),e=r,e!==n?(t.setValue(e),!0):!1}function fi(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}function Al(e,t){var n=t.checked;return pe({},t,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:n??e._wrapperState.initialChecked})}function Ma(e,t){var n=t.defaultValue==null?"":t.defaultValue,r=t.checked!=null?t.checked:t.defaultChecked;n=an(t.value!=null?t.value:n),e._wrapperState={initialChecked:r,initialValue:n,controlled:t.type==="checkbox"||t.type==="radio"?t.checked!=null:t.value!=null}}function Ff(e,t){t=t.checked,t!=null&&Ss(e,"checked",t,!1)}function _l(e,t){Ff(e,t);var n=an(t.value),r=t.type;if(n!=null)r==="number"?(n===0&&e.value===""||e.value!=n)&&(e.value=""+n):e.value!==""+n&&(e.value=""+n);else if(r==="submit"||r==="reset"){e.removeAttribute("value");return}t.hasOwnProperty("value")?Dl(e,t.type,n):t.hasOwnProperty("defaultValue")&&Dl(e,t.type,an(t.defaultValue)),t.checked==null&&t.defaultChecked!=null&&(e.defaultChecked=!!t.defaultChecked)}function $a(e,t,n){if(t.hasOwnProperty("value")||t.hasOwnProperty("defaultValue")){var r=t.type;if(!(r!=="submit"&&r!=="reset"||t.value!==void 0&&t.value!==null))return;t=""+e._wrapperState.initialValue,n||t===e.value||(e.value=t),e.defaultValue=t}n=e.name,n!==""&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,n!==""&&(e.name=n)}function Dl(e,t,n){(t!=="number"||fi(e.ownerDocument)!==e)&&(n==null?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+n&&(e.defaultValue=""+n))}var Ir=Array.isArray;function rr(e,t,n,r){if(e=e.options,t){t={};for(var o=0;o"+t.valueOf().toString()+"",t=No.firstChild;e.firstChild;)e.removeChild(e.firstChild);for(;t.firstChild;)e.appendChild(t.firstChild)}});function Zr(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&n.nodeType===3){n.nodeValue=t;return}}e.textContent=t}var Mr={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},uh=["Webkit","ms","Moz","O"];Object.keys(Mr).forEach(function(e){uh.forEach(function(t){t=t+e.charAt(0).toUpperCase()+e.substring(1),Mr[t]=Mr[e]})});function Of(e,t,n){return t==null||typeof t=="boolean"||t===""?"":n||typeof t!="number"||t===0||Mr.hasOwnProperty(e)&&Mr[e]?(""+t).trim():t+"px"}function jf(e,t){e=e.style;for(var n in t)if(t.hasOwnProperty(n)){var r=n.indexOf("--")===0,o=Of(n,t[n],r);n==="float"&&(n="cssFloat"),r?e.setProperty(n,o):e[n]=o}}var ch=pe({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function Rl(e,t){if(t){if(ch[e]&&(t.children!=null||t.dangerouslySetInnerHTML!=null))throw Error(b(137,e));if(t.dangerouslySetInnerHTML!=null){if(t.children!=null)throw Error(b(60));if(typeof t.dangerouslySetInnerHTML!="object"||!("__html"in t.dangerouslySetInnerHTML))throw Error(b(61))}if(t.style!=null&&typeof t.style!="object")throw Error(b(62))}}function Pl(e,t){if(e.indexOf("-")===-1)return typeof t.is=="string";switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var Ol=null;function Fs(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var jl=null,or=null,ir=null;function Va(e){if(e=wo(e)){if(typeof jl!="function")throw Error(b(280));var t=e.stateNode;t&&(t=Mi(t),jl(e.stateNode,e.type,t))}}function Nf(e){or?ir?ir.push(e):ir=[e]:or=e}function Tf(){if(or){var e=or,t=ir;if(ir=or=null,Va(e),t)for(e=0;e>>=0,e===0?32:31-(Ch(e)/wh|0)|0}var To=64,Lo=4194304;function Ur(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return e&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function hi(e,t){var n=e.pendingLanes;if(n===0)return 0;var r=0,o=e.suspendedLanes,i=e.pingedLanes,l=n&268435455;if(l!==0){var s=l&~o;s!==0?r=Ur(s):(i&=l,i!==0&&(r=Ur(i)))}else l=n&~o,l!==0?r=Ur(l):i!==0&&(r=Ur(i));if(r===0)return 0;if(t!==0&&t!==r&&!(t&o)&&(o=r&-r,i=t&-t,o>=i||o===16&&(i&4194240)!==0))return t;if(r&4&&(r|=n&16),t=e.entangledLanes,t!==0)for(e=e.entanglements,t&=r;0n;n++)t.push(e);return t}function Eo(e,t,n){e.pendingLanes|=t,t!==536870912&&(e.suspendedLanes=0,e.pingedLanes=0),e=e.eventTimes,t=31-gt(t),e[t]=n}function _h(e,t){var n=e.pendingLanes&~t;e.pendingLanes=t,e.suspendedLanes=0,e.pingedLanes=0,e.expiredLanes&=t,e.mutableReadLanes&=t,e.entangledLanes&=t,t=e.entanglements;var r=e.eventTimes;for(e=e.expirationTimes;0=Wr),tu=" ",nu=!1;function td(e,t){switch(e){case"keyup":return e1.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function nd(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var Kn=!1;function n1(e,t){switch(e){case"compositionend":return nd(t);case"keypress":return t.which!==32?null:(nu=!0,tu);case"textInput":return e=t.data,e===tu&&nu?null:e;default:return null}}function r1(e,t){if(Kn)return e==="compositionend"||!Ls&&td(e,t)?(e=Jf(),Zo=js=Gt=null,Kn=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1=t)return{node:n,offset:t-e};e=r}e:{for(;n;){if(n.nextSibling){n=n.nextSibling;break e}n=n.parentNode}n=void 0}n=lu(n)}}function ld(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?ld(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function sd(){for(var e=window,t=fi();t instanceof e.HTMLIFrameElement;){try{var n=typeof t.contentWindow.location.href=="string"}catch{n=!1}if(n)e=t.contentWindow;else break;t=fi(e.document)}return t}function zs(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}function d1(e){var t=sd(),n=e.focusedElem,r=e.selectionRange;if(t!==n&&n&&n.ownerDocument&&ld(n.ownerDocument.documentElement,n)){if(r!==null&&zs(n)){if(t=r.start,e=r.end,e===void 0&&(e=t),"selectionStart"in n)n.selectionStart=t,n.selectionEnd=Math.min(e,n.value.length);else if(e=(t=n.ownerDocument||document)&&t.defaultView||window,e.getSelection){e=e.getSelection();var o=n.textContent.length,i=Math.min(r.start,o);r=r.end===void 0?i:Math.min(r.end,o),!e.extend&&i>r&&(o=r,r=i,i=o),o=su(n,i);var l=su(n,r);o&&l&&(e.rangeCount!==1||e.anchorNode!==o.node||e.anchorOffset!==o.offset||e.focusNode!==l.node||e.focusOffset!==l.offset)&&(t=t.createRange(),t.setStart(o.node,o.offset),e.removeAllRanges(),i>r?(e.addRange(t),e.extend(l.node,l.offset)):(t.setEnd(l.node,l.offset),e.addRange(t)))}}for(t=[],e=n;e=e.parentNode;)e.nodeType===1&&t.push({element:e,left:e.scrollLeft,top:e.scrollTop});for(typeof n.focus=="function"&&n.focus(),n=0;n=document.documentMode,Qn=null,Il=null,Vr=null,Ul=!1;function au(e,t,n){var r=n.window===n?n.document:n.nodeType===9?n:n.ownerDocument;Ul||Qn==null||Qn!==fi(r)||(r=Qn,"selectionStart"in r&&zs(r)?r={start:r.selectionStart,end:r.selectionEnd}:(r=(r.ownerDocument&&r.ownerDocument.defaultView||window).getSelection(),r={anchorNode:r.anchorNode,anchorOffset:r.anchorOffset,focusNode:r.focusNode,focusOffset:r.focusOffset}),Vr&&oo(Vr,r)||(Vr=r,r=yi(Il,"onSelect"),0Yn||(e.current=Vl[Yn],Vl[Yn]=null,Yn--)}function le(e,t){Yn++,Vl[Yn]=e.current,e.current=t}var un={},Ie=dn(un),Xe=dn(!1),Dn=un;function cr(e,t){var n=e.type.contextTypes;if(!n)return un;var r=e.stateNode;if(r&&r.__reactInternalMemoizedUnmaskedChildContext===t)return r.__reactInternalMemoizedMaskedChildContext;var o={},i;for(i in n)o[i]=t[i];return r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=t,e.__reactInternalMemoizedMaskedChildContext=o),o}function Ge(e){return e=e.childContextTypes,e!=null}function Ei(){ae(Xe),ae(Ie)}function hu(e,t,n){if(Ie.current!==un)throw Error(b(168));le(Ie,t),le(Xe,n)}function vd(e,t,n){var r=e.stateNode;if(t=t.childContextTypes,typeof r.getChildContext!="function")return n;r=r.getChildContext();for(var o in r)if(!(o in t))throw Error(b(108,sh(e)||"Unknown",o));return pe({},n,r)}function Ci(e){return e=(e=e.stateNode)&&e.__reactInternalMemoizedMergedChildContext||un,Dn=Ie.current,le(Ie,e),le(Xe,Xe.current),!0}function vu(e,t,n){var r=e.stateNode;if(!r)throw Error(b(169));n?(e=vd(e,t,Dn),r.__reactInternalMemoizedMergedChildContext=e,ae(Xe),ae(Ie),le(Ie,e)):ae(Xe),le(Xe,n)}var Nt=null,$i=!1,C0=!1;function md(e){Nt===null?Nt=[e]:Nt.push(e)}function S1(e){$i=!0,md(e)}function xn(){if(!C0&&Nt!==null){C0=!0;var e=0,t=ne;try{var n=Nt;for(ne=1;e>=l,o-=l,Tt=1<<32-gt(t)+o|n<D?(P=S,S=null):P=S.sibling;var A=x(p,S,h[D],v);if(A===null){S===null&&(S=P);break}e&&S&&A.alternate===null&&t(p,S),c=i(A,c,D),B===null?w=A:B.sibling=A,B=A,S=P}if(D===h.length)return n(p,S),ue&&vn(p,D),w;if(S===null){for(;DD?(P=S,S=null):P=S.sibling;var F=x(p,S,A.value,v);if(F===null){S===null&&(S=P);break}e&&S&&F.alternate===null&&t(p,S),c=i(F,c,D),B===null?w=F:B.sibling=F,B=F,S=P}if(A.done)return n(p,S),ue&&vn(p,D),w;if(S===null){for(;!A.done;D++,A=h.next())A=d(p,A.value,v),A!==null&&(c=i(A,c,D),B===null?w=A:B.sibling=A,B=A);return ue&&vn(p,D),w}for(S=r(p,S);!A.done;D++,A=h.next())A=m(S,p,D,A.value,v),A!==null&&(e&&A.alternate!==null&&S.delete(A.key===null?D:A.key),c=i(A,c,D),B===null?w=A:B.sibling=A,B=A);return e&&S.forEach(function(j){return t(p,j)}),ue&&vn(p,D),w}function E(p,c,h,v){if(typeof h=="object"&&h!==null&&h.type===Vn&&h.key===null&&(h=h.props.children),typeof h=="object"&&h!==null){switch(h.$$typeof){case Oo:e:{for(var w=h.key,B=c;B!==null;){if(B.key===w){if(w=h.type,w===Vn){if(B.tag===7){n(p,B.sibling),c=o(B,h.props.children),c.return=p,p=c;break e}}else if(B.elementType===w||typeof w=="object"&&w!==null&&w.$$typeof===Vt&&gu(w)===B.type){n(p,B.sibling),c=o(B,h.props),c.ref=Or(p,B,h),c.return=p,p=c;break e}n(p,B);break}else t(p,B);B=B.sibling}h.type===Vn?(c=Sn(h.props.children,p.mode,v,h.key),c.return=p,p=c):(v=li(h.type,h.key,h.props,null,p.mode,v),v.ref=Or(p,c,h),v.return=p,p=v)}return l(p);case qn:e:{for(B=h.key;c!==null;){if(c.key===B)if(c.tag===4&&c.stateNode.containerInfo===h.containerInfo&&c.stateNode.implementation===h.implementation){n(p,c.sibling),c=o(c,h.children||[]),c.return=p,p=c;break e}else{n(p,c);break}else t(p,c);c=c.sibling}c=k0(h,p.mode,v),c.return=p,p=c}return l(p);case Vt:return B=h._init,E(p,c,B(h._payload),v)}if(Ir(h))return y(p,c,h,v);if(Dr(h))return g(p,c,h,v);$o(p,h)}return typeof h=="string"&&h!==""||typeof h=="number"?(h=""+h,c!==null&&c.tag===6?(n(p,c.sibling),c=o(c,h),c.return=p,p=c):(n(p,c),c=F0(h,p.mode,v),c.return=p,p=c),l(p)):n(p,c)}return E}var dr=Cd(!0),wd=Cd(!1),Si=dn(null),Ai=null,er=null,Hs=null;function Ms(){Hs=er=Ai=null}function $s(e){var t=Si.current;ae(Si),e._currentValue=t}function Xl(e,t,n){for(;e!==null;){var r=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,r!==null&&(r.childLanes|=t)):r!==null&&(r.childLanes&t)!==t&&(r.childLanes|=t),e===n)break;e=e.return}}function sr(e,t){Ai=e,Hs=er=null,e=e.dependencies,e!==null&&e.firstContext!==null&&(e.lanes&t&&(Qe=!0),e.firstContext=null)}function ft(e){var t=e._currentValue;if(Hs!==e)if(e={context:e,memoizedValue:t,next:null},er===null){if(Ai===null)throw Error(b(308));er=e,Ai.dependencies={lanes:0,firstContext:e}}else er=er.next=e;return t}var En=null;function Ws(e){En===null?En=[e]:En.push(e)}function Bd(e,t,n,r){var o=t.interleaved;return o===null?(n.next=n,Ws(t)):(n.next=o.next,o.next=n),t.interleaved=n,Ut(e,r)}function Ut(e,t){e.lanes|=t;var n=e.alternate;for(n!==null&&(n.lanes|=t),n=e,e=e.return;e!==null;)e.childLanes|=t,n=e.alternate,n!==null&&(n.childLanes|=t),n=e,e=e.return;return n.tag===3?n.stateNode:null}var Kt=!1;function qs(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function Sd(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function zt(e,t){return{eventTime:e,lane:t,tag:0,payload:null,callback:null,next:null}}function rn(e,t,n){var r=e.updateQueue;if(r===null)return null;if(r=r.shared,te&2){var o=r.pending;return o===null?t.next=t:(t.next=o.next,o.next=t),r.pending=t,Ut(e,n)}return o=r.interleaved,o===null?(t.next=t,Ws(r)):(t.next=o.next,o.next=t),r.interleaved=t,Ut(e,n)}function ei(e,t,n){if(t=t.updateQueue,t!==null&&(t=t.shared,(n&4194240)!==0)){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,Rs(e,n)}}function Eu(e,t){var n=e.updateQueue,r=e.alternate;if(r!==null&&(r=r.updateQueue,n===r)){var o=null,i=null;if(n=n.firstBaseUpdate,n!==null){do{var l={eventTime:n.eventTime,lane:n.lane,tag:n.tag,payload:n.payload,callback:n.callback,next:null};i===null?o=i=l:i=i.next=l,n=n.next}while(n!==null);i===null?o=i=t:i=i.next=t}else o=i=t;n={baseState:r.baseState,firstBaseUpdate:o,lastBaseUpdate:i,shared:r.shared,effects:r.effects},e.updateQueue=n;return}e=n.lastBaseUpdate,e===null?n.firstBaseUpdate=t:e.next=t,n.lastBaseUpdate=t}function _i(e,t,n,r){var o=e.updateQueue;Kt=!1;var i=o.firstBaseUpdate,l=o.lastBaseUpdate,s=o.shared.pending;if(s!==null){o.shared.pending=null;var a=s,u=a.next;a.next=null,l===null?i=u:l.next=u,l=a;var f=e.alternate;f!==null&&(f=f.updateQueue,s=f.lastBaseUpdate,s!==l&&(s===null?f.firstBaseUpdate=u:s.next=u,f.lastBaseUpdate=a))}if(i!==null){var d=o.baseState;l=0,f=u=a=null,s=i;do{var x=s.lane,m=s.eventTime;if((r&x)===x){f!==null&&(f=f.next={eventTime:m,lane:0,tag:s.tag,payload:s.payload,callback:s.callback,next:null});e:{var y=e,g=s;switch(x=t,m=n,g.tag){case 1:if(y=g.payload,typeof y=="function"){d=y.call(m,d,x);break e}d=y;break e;case 3:y.flags=y.flags&-65537|128;case 0:if(y=g.payload,x=typeof y=="function"?y.call(m,d,x):y,x==null)break e;d=pe({},d,x);break e;case 2:Kt=!0}}s.callback!==null&&s.lane!==0&&(e.flags|=64,x=o.effects,x===null?o.effects=[s]:x.push(s))}else m={eventTime:m,lane:x,tag:s.tag,payload:s.payload,callback:s.callback,next:null},f===null?(u=f=m,a=d):f=f.next=m,l|=x;if(s=s.next,s===null){if(s=o.shared.pending,s===null)break;x=s,s=x.next,x.next=null,o.lastBaseUpdate=x,o.shared.pending=null}}while(!0);if(f===null&&(a=d),o.baseState=a,o.firstBaseUpdate=u,o.lastBaseUpdate=f,t=o.shared.interleaved,t!==null){o=t;do l|=o.lane,o=o.next;while(o!==t)}else i===null&&(o.shared.lanes=0);Rn|=l,e.lanes=l,e.memoizedState=d}}function Cu(e,t,n){if(e=t.effects,t.effects=null,e!==null)for(t=0;tn?n:4,e(!0);var r=B0.transition;B0.transition={};try{e(!1),t()}finally{ne=n,B0.transition=r}}function Hd(){return dt().memoizedState}function F1(e,t,n){var r=ln(e);if(n={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null},Md(e))$d(t,n);else if(n=Bd(e,t,n,r),n!==null){var o=Me();Et(n,e,r,o),Wd(n,t,r)}}function k1(e,t,n){var r=ln(e),o={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null};if(Md(e))$d(t,o);else{var i=e.alternate;if(e.lanes===0&&(i===null||i.lanes===0)&&(i=t.lastRenderedReducer,i!==null))try{var l=t.lastRenderedState,s=i(l,n);if(o.hasEagerState=!0,o.eagerState=s,Ct(s,l)){var a=t.interleaved;a===null?(o.next=o,Ws(t)):(o.next=a.next,a.next=o),t.interleaved=o;return}}catch{}finally{}n=Bd(e,t,o,r),n!==null&&(o=Me(),Et(n,e,r,o),Wd(n,t,r))}}function Md(e){var t=e.alternate;return e===xe||t!==null&&t===xe}function $d(e,t){Kr=Fi=!0;var n=e.pending;n===null?t.next=t:(t.next=n.next,n.next=t),e.pending=t}function Wd(e,t,n){if(n&4194240){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,Rs(e,n)}}var ki={readContext:ft,useCallback:je,useContext:je,useEffect:je,useImperativeHandle:je,useInsertionEffect:je,useLayoutEffect:je,useMemo:je,useReducer:je,useRef:je,useState:je,useDebugValue:je,useDeferredValue:je,useTransition:je,useMutableSource:je,useSyncExternalStore:je,useId:je,unstable_isNewReconciler:!1},R1={readContext:ft,useCallback:function(e,t){return Dt().memoizedState=[e,t===void 0?null:t],e},useContext:ft,useEffect:Bu,useImperativeHandle:function(e,t,n){return n=n!=null?n.concat([e]):null,ni(4194308,4,Ld.bind(null,t,e),n)},useLayoutEffect:function(e,t){return ni(4194308,4,e,t)},useInsertionEffect:function(e,t){return ni(4,2,e,t)},useMemo:function(e,t){var n=Dt();return t=t===void 0?null:t,e=e(),n.memoizedState=[e,t],e},useReducer:function(e,t,n){var r=Dt();return t=n!==void 0?n(t):t,r.memoizedState=r.baseState=t,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:t},r.queue=e,e=e.dispatch=F1.bind(null,xe,e),[r.memoizedState,e]},useRef:function(e){var t=Dt();return e={current:e},t.memoizedState=e},useState:wu,useDebugValue:Js,useDeferredValue:function(e){return Dt().memoizedState=e},useTransition:function(){var e=wu(!1),t=e[0];return e=D1.bind(null,e[1]),Dt().memoizedState=e,[t,e]},useMutableSource:function(){},useSyncExternalStore:function(e,t,n){var r=xe,o=Dt();if(ue){if(n===void 0)throw Error(b(407));n=n()}else{if(n=t(),De===null)throw Error(b(349));kn&30||Fd(r,t,n)}o.memoizedState=n;var i={value:n,getSnapshot:t};return o.queue=i,Bu(Rd.bind(null,r,i,e),[e]),r.flags|=2048,xo(9,kd.bind(null,r,i,n,t),void 0,null),n},useId:function(){var e=Dt(),t=De.identifierPrefix;if(ue){var n=Lt,r=Tt;n=(r&~(1<<32-gt(r)-1)).toString(32)+n,t=":"+t+"R"+n,n=co++,0<\/script>",e=e.removeChild(e.firstChild)):typeof r.is=="string"?e=l.createElement(n,{is:r.is}):(e=l.createElement(n),n==="select"&&(l=e,r.multiple?l.multiple=!0:r.size&&(l.size=r.size))):e=l.createElementNS(e,n),e[Ft]=t,e[so]=r,ex(e,t,!1,!1),t.stateNode=e;e:{switch(l=Pl(n,r),n){case"dialog":se("cancel",e),se("close",e),o=r;break;case"iframe":case"object":case"embed":se("load",e),o=r;break;case"video":case"audio":for(o=0;ohr&&(t.flags|=128,r=!0,jr(i,!1),t.lanes=4194304)}else{if(!r)if(e=Di(l),e!==null){if(t.flags|=128,r=!0,n=e.updateQueue,n!==null&&(t.updateQueue=n,t.flags|=4),jr(i,!0),i.tail===null&&i.tailMode==="hidden"&&!l.alternate&&!ue)return Ne(t),null}else 2*me()-i.renderingStartTime>hr&&n!==1073741824&&(t.flags|=128,r=!0,jr(i,!1),t.lanes=4194304);i.isBackwards?(l.sibling=t.child,t.child=l):(n=i.last,n!==null?n.sibling=l:t.child=l,i.last=l)}return i.tail!==null?(t=i.tail,i.rendering=t,i.tail=t.sibling,i.renderingStartTime=me(),t.sibling=null,n=fe.current,le(fe,r?n&1|2:n&1),t):(Ne(t),null);case 22:case 23:return ia(),r=t.memoizedState!==null,e!==null&&e.memoizedState!==null!==r&&(t.flags|=8192),r&&t.mode&1?et&1073741824&&(Ne(t),t.subtreeFlags&6&&(t.flags|=8192)):Ne(t),null;case 24:return null;case 25:return null}throw Error(b(156,t.tag))}function b1(e,t){switch(Is(t),t.tag){case 1:return Ge(t.type)&&Ei(),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return xr(),ae(Xe),ae(Ie),Qs(),e=t.flags,e&65536&&!(e&128)?(t.flags=e&-65537|128,t):null;case 5:return Ks(t),null;case 13:if(ae(fe),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(b(340));fr()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return ae(fe),null;case 4:return xr(),null;case 10:return $s(t.type._context),null;case 22:case 23:return ia(),null;case 24:return null;default:return null}}var qo=!1,Le=!1,I1=typeof WeakSet=="function"?WeakSet:Set,$=null;function tr(e,t){var n=e.ref;if(n!==null)if(typeof n=="function")try{n(null)}catch(r){he(e,t,r)}else n.current=null}function os(e,t,n){try{n()}catch(r){he(e,t,r)}}var Nu=!1;function U1(e,t){if(Hl=vi,e=sd(),zs(e)){if("selectionStart"in e)var n={start:e.selectionStart,end:e.selectionEnd};else e:{n=(n=e.ownerDocument)&&n.defaultView||window;var r=n.getSelection&&n.getSelection();if(r&&r.rangeCount!==0){n=r.anchorNode;var o=r.anchorOffset,i=r.focusNode;r=r.focusOffset;try{n.nodeType,i.nodeType}catch{n=null;break e}var l=0,s=-1,a=-1,u=0,f=0,d=e,x=null;t:for(;;){for(var m;d!==n||o!==0&&d.nodeType!==3||(s=l+o),d!==i||r!==0&&d.nodeType!==3||(a=l+r),d.nodeType===3&&(l+=d.nodeValue.length),(m=d.firstChild)!==null;)x=d,d=m;for(;;){if(d===e)break t;if(x===n&&++u===o&&(s=l),x===i&&++f===r&&(a=l),(m=d.nextSibling)!==null)break;d=x,x=d.parentNode}d=m}n=s===-1||a===-1?null:{start:s,end:a}}else n=null}n=n||{start:0,end:0}}else n=null;for(Ml={focusedElem:e,selectionRange:n},vi=!1,$=t;$!==null;)if(t=$,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,$=e;else for(;$!==null;){t=$;try{var y=t.alternate;if(t.flags&1024)switch(t.tag){case 0:case 11:case 15:break;case 1:if(y!==null){var g=y.memoizedProps,E=y.memoizedState,p=t.stateNode,c=p.getSnapshotBeforeUpdate(t.elementType===t.type?g:ht(t.type,g),E);p.__reactInternalSnapshotBeforeUpdate=c}break;case 3:var h=t.stateNode.containerInfo;h.nodeType===1?h.textContent="":h.nodeType===9&&h.documentElement&&h.removeChild(h.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(b(163))}}catch(v){he(t,t.return,v)}if(e=t.sibling,e!==null){e.return=t.return,$=e;break}$=t.return}return y=Nu,Nu=!1,y}function Qr(e,t,n){var r=t.updateQueue;if(r=r!==null?r.lastEffect:null,r!==null){var o=r=r.next;do{if((o.tag&e)===e){var i=o.destroy;o.destroy=void 0,i!==void 0&&os(t,n,i)}o=o.next}while(o!==r)}}function Vi(e,t){if(t=t.updateQueue,t=t!==null?t.lastEffect:null,t!==null){var n=t=t.next;do{if((n.tag&e)===e){var r=n.create;n.destroy=r()}n=n.next}while(n!==t)}}function is(e){var t=e.ref;if(t!==null){var n=e.stateNode;switch(e.tag){case 5:e=n;break;default:e=n}typeof t=="function"?t(e):t.current=e}}function rx(e){var t=e.alternate;t!==null&&(e.alternate=null,rx(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&(delete t[Ft],delete t[so],delete t[ql],delete t[w1],delete t[B1])),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function ox(e){return e.tag===5||e.tag===3||e.tag===4}function Tu(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||ox(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function ls(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.nodeType===8?n.parentNode.insertBefore(e,t):n.insertBefore(e,t):(n.nodeType===8?(t=n.parentNode,t.insertBefore(e,n)):(t=n,t.appendChild(e)),n=n._reactRootContainer,n!=null||t.onclick!==null||(t.onclick=gi));else if(r!==4&&(e=e.child,e!==null))for(ls(e,t,n),e=e.sibling;e!==null;)ls(e,t,n),e=e.sibling}function ss(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.insertBefore(e,t):n.appendChild(e);else if(r!==4&&(e=e.child,e!==null))for(ss(e,t,n),e=e.sibling;e!==null;)ss(e,t,n),e=e.sibling}var Re=null,vt=!1;function Wt(e,t,n){for(n=n.child;n!==null;)ix(e,t,n),n=n.sibling}function ix(e,t,n){if(kt&&typeof kt.onCommitFiberUnmount=="function")try{kt.onCommitFiberUnmount(bi,n)}catch{}switch(n.tag){case 5:Le||tr(n,t);case 6:var r=Re,o=vt;Re=null,Wt(e,t,n),Re=r,vt=o,Re!==null&&(vt?(e=Re,n=n.stateNode,e.nodeType===8?e.parentNode.removeChild(n):e.removeChild(n)):Re.removeChild(n.stateNode));break;case 18:Re!==null&&(vt?(e=Re,n=n.stateNode,e.nodeType===8?E0(e.parentNode,n):e.nodeType===1&&E0(e,n),no(e)):E0(Re,n.stateNode));break;case 4:r=Re,o=vt,Re=n.stateNode.containerInfo,vt=!0,Wt(e,t,n),Re=r,vt=o;break;case 0:case 11:case 14:case 15:if(!Le&&(r=n.updateQueue,r!==null&&(r=r.lastEffect,r!==null))){o=r=r.next;do{var i=o,l=i.destroy;i=i.tag,l!==void 0&&(i&2||i&4)&&os(n,t,l),o=o.next}while(o!==r)}Wt(e,t,n);break;case 1:if(!Le&&(tr(n,t),r=n.stateNode,typeof r.componentWillUnmount=="function"))try{r.props=n.memoizedProps,r.state=n.memoizedState,r.componentWillUnmount()}catch(s){he(n,t,s)}Wt(e,t,n);break;case 21:Wt(e,t,n);break;case 22:n.mode&1?(Le=(r=Le)||n.memoizedState!==null,Wt(e,t,n),Le=r):Wt(e,t,n);break;default:Wt(e,t,n)}}function Lu(e){var t=e.updateQueue;if(t!==null){e.updateQueue=null;var n=e.stateNode;n===null&&(n=e.stateNode=new I1),t.forEach(function(r){var o=X1.bind(null,e,r);n.has(r)||(n.add(r),r.then(o,o))})}}function pt(e,t){var n=t.deletions;if(n!==null)for(var r=0;ro&&(o=l),r&=~i}if(r=o,r=me()-r,r=(120>r?120:480>r?480:1080>r?1080:1920>r?1920:3e3>r?3e3:4320>r?4320:1960*M1(r/1960))-r,10e?16:e,Yt===null)var r=!1;else{if(e=Yt,Yt=null,Oi=0,te&6)throw Error(b(331));var o=te;for(te|=4,$=e.current;$!==null;){var i=$,l=i.child;if($.flags&16){var s=i.deletions;if(s!==null){for(var a=0;ame()-ra?Bn(e,0):na|=n),Ye(e,t)}function xx(e,t){t===0&&(e.mode&1?(t=Lo,Lo<<=1,!(Lo&130023424)&&(Lo=4194304)):t=1);var n=Me();e=Ut(e,t),e!==null&&(Eo(e,t,n),Ye(e,n))}function Q1(e){var t=e.memoizedState,n=0;t!==null&&(n=t.retryLane),xx(e,n)}function X1(e,t){var n=0;switch(e.tag){case 13:var r=e.stateNode,o=e.memoizedState;o!==null&&(n=o.retryLane);break;case 19:r=e.stateNode;break;default:throw Error(b(314))}r!==null&&r.delete(t),xx(e,n)}var px;px=function(e,t,n){if(e!==null)if(e.memoizedProps!==t.pendingProps||Xe.current)Qe=!0;else{if(!(e.lanes&n)&&!(t.flags&128))return Qe=!1,L1(e,t,n);Qe=!!(e.flags&131072)}else Qe=!1,ue&&t.flags&1048576&&yd(t,Bi,t.index);switch(t.lanes=0,t.tag){case 2:var r=t.type;ri(e,t),e=t.pendingProps;var o=cr(t,Ie.current);sr(t,n),o=Gs(null,t,r,e,o,n);var i=Ys();return t.flags|=1,typeof o=="object"&&o!==null&&typeof o.render=="function"&&o.$$typeof===void 0?(t.tag=1,t.memoizedState=null,t.updateQueue=null,Ge(r)?(i=!0,Ci(t)):i=!1,t.memoizedState=o.state!==null&&o.state!==void 0?o.state:null,qs(t),o.updater=qi,t.stateNode=o,o._reactInternals=t,Yl(t,r,e,n),t=es(null,t,r,!0,i,n)):(t.tag=0,ue&&i&&bs(t),He(null,t,o,n),t=t.child),t;case 16:r=t.elementType;e:{switch(ri(e,t),e=t.pendingProps,o=r._init,r=o(r._payload),t.type=r,o=t.tag=Y1(r),e=ht(r,e),o){case 0:t=Jl(null,t,r,e,n);break e;case 1:t=Pu(null,t,r,e,n);break e;case 11:t=ku(null,t,r,e,n);break e;case 14:t=Ru(null,t,r,ht(r.type,e),n);break e}throw Error(b(306,r,""))}return t;case 0:return r=t.type,o=t.pendingProps,o=t.elementType===r?o:ht(r,o),Jl(e,t,r,o,n);case 1:return r=t.type,o=t.pendingProps,o=t.elementType===r?o:ht(r,o),Pu(e,t,r,o,n);case 3:e:{if(Yd(t),e===null)throw Error(b(387));r=t.pendingProps,i=t.memoizedState,o=i.element,Sd(e,t),_i(t,r,null,n);var l=t.memoizedState;if(r=l.element,i.isDehydrated)if(i={element:r,isDehydrated:!1,cache:l.cache,pendingSuspenseBoundaries:l.pendingSuspenseBoundaries,transitions:l.transitions},t.updateQueue.baseState=i,t.memoizedState=i,t.flags&256){o=pr(Error(b(423)),t),t=Ou(e,t,r,n,o);break e}else if(r!==o){o=pr(Error(b(424)),t),t=Ou(e,t,r,n,o);break e}else for(tt=nn(t.stateNode.containerInfo.firstChild),nt=t,ue=!0,mt=null,n=wd(t,null,r,n),t.child=n;n;)n.flags=n.flags&-3|4096,n=n.sibling;else{if(fr(),r===o){t=Ht(e,t,n);break e}He(e,t,r,n)}t=t.child}return t;case 5:return Ad(t),e===null&&Ql(t),r=t.type,o=t.pendingProps,i=e!==null?e.memoizedProps:null,l=o.children,$l(r,o)?l=null:i!==null&&$l(r,i)&&(t.flags|=32),Gd(e,t),He(e,t,l,n),t.child;case 6:return e===null&&Ql(t),null;case 13:return Zd(e,t,n);case 4:return Vs(t,t.stateNode.containerInfo),r=t.pendingProps,e===null?t.child=dr(t,null,r,n):He(e,t,r,n),t.child;case 11:return r=t.type,o=t.pendingProps,o=t.elementType===r?o:ht(r,o),ku(e,t,r,o,n);case 7:return He(e,t,t.pendingProps,n),t.child;case 8:return He(e,t,t.pendingProps.children,n),t.child;case 12:return He(e,t,t.pendingProps.children,n),t.child;case 10:e:{if(r=t.type._context,o=t.pendingProps,i=t.memoizedProps,l=o.value,le(Si,r._currentValue),r._currentValue=l,i!==null)if(Ct(i.value,l)){if(i.children===o.children&&!Xe.current){t=Ht(e,t,n);break e}}else for(i=t.child,i!==null&&(i.return=t);i!==null;){var s=i.dependencies;if(s!==null){l=i.child;for(var a=s.firstContext;a!==null;){if(a.context===r){if(i.tag===1){a=zt(-1,n&-n),a.tag=2;var u=i.updateQueue;if(u!==null){u=u.shared;var f=u.pending;f===null?a.next=a:(a.next=f.next,f.next=a),u.pending=a}}i.lanes|=n,a=i.alternate,a!==null&&(a.lanes|=n),Xl(i.return,n,t),s.lanes|=n;break}a=a.next}}else if(i.tag===10)l=i.type===t.type?null:i.child;else if(i.tag===18){if(l=i.return,l===null)throw Error(b(341));l.lanes|=n,s=l.alternate,s!==null&&(s.lanes|=n),Xl(l,n,t),l=i.sibling}else l=i.child;if(l!==null)l.return=i;else for(l=i;l!==null;){if(l===t){l=null;break}if(i=l.sibling,i!==null){i.return=l.return,l=i;break}l=l.return}i=l}He(e,t,o.children,n),t=t.child}return t;case 9:return o=t.type,r=t.pendingProps.children,sr(t,n),o=ft(o),r=r(o),t.flags|=1,He(e,t,r,n),t.child;case 14:return r=t.type,o=ht(r,t.pendingProps),o=ht(r.type,o),Ru(e,t,r,o,n);case 15:return Qd(e,t,t.type,t.pendingProps,n);case 17:return r=t.type,o=t.pendingProps,o=t.elementType===r?o:ht(r,o),ri(e,t),t.tag=1,Ge(r)?(e=!0,Ci(t)):e=!1,sr(t,n),qd(t,r,o),Yl(t,r,o,n),es(null,t,r,!0,e,n);case 19:return Jd(e,t,n);case 22:return Xd(e,t,n)}throw Error(b(156,t.tag))};function hx(e,t){return Mf(e,t)}function G1(e,t,n,r){this.tag=e,this.key=n,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=r,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function at(e,t,n,r){return new G1(e,t,n,r)}function sa(e){return e=e.prototype,!(!e||!e.isReactComponent)}function Y1(e){if(typeof e=="function")return sa(e)?1:0;if(e!=null){if(e=e.$$typeof,e===_s)return 11;if(e===Ds)return 14}return 2}function sn(e,t){var n=e.alternate;return n===null?(n=at(e.tag,t,e.key,e.mode),n.elementType=e.elementType,n.type=e.type,n.stateNode=e.stateNode,n.alternate=e,e.alternate=n):(n.pendingProps=t,n.type=e.type,n.flags=0,n.subtreeFlags=0,n.deletions=null),n.flags=e.flags&14680064,n.childLanes=e.childLanes,n.lanes=e.lanes,n.child=e.child,n.memoizedProps=e.memoizedProps,n.memoizedState=e.memoizedState,n.updateQueue=e.updateQueue,t=e.dependencies,n.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},n.sibling=e.sibling,n.index=e.index,n.ref=e.ref,n}function li(e,t,n,r,o,i){var l=2;if(r=e,typeof e=="function")sa(e)&&(l=1);else if(typeof e=="string")l=5;else e:switch(e){case Vn:return Sn(n.children,o,i,t);case As:l=8,o|=8;break;case Cl:return e=at(12,n,t,o|2),e.elementType=Cl,e.lanes=i,e;case wl:return e=at(13,n,t,o),e.elementType=wl,e.lanes=i,e;case Bl:return e=at(19,n,t,o),e.elementType=Bl,e.lanes=i,e;case Af:return Qi(n,o,i,t);default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case Bf:l=10;break e;case Sf:l=9;break e;case _s:l=11;break e;case Ds:l=14;break e;case Vt:l=16,r=null;break e}throw Error(b(130,e==null?e:typeof e,""))}return t=at(l,n,t,o),t.elementType=e,t.type=r,t.lanes=i,t}function Sn(e,t,n,r){return e=at(7,e,r,t),e.lanes=n,e}function Qi(e,t,n,r){return e=at(22,e,r,t),e.elementType=Af,e.lanes=n,e.stateNode={isHidden:!1},e}function F0(e,t,n){return e=at(6,e,null,t),e.lanes=n,e}function k0(e,t,n){return t=at(4,e.children!==null?e.children:[],e.key,t),t.lanes=n,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}function Z1(e,t,n,r,o){this.tag=t,this.containerInfo=e,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=u0(0),this.expirationTimes=u0(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=u0(0),this.identifierPrefix=r,this.onRecoverableError=o,this.mutableSourceEagerHydrationData=null}function aa(e,t,n,r,o,i,l,s,a){return e=new Z1(e,t,n,s,a),t===1?(t=1,i===!0&&(t|=8)):t=0,i=at(3,null,null,t),e.current=i,i.stateNode=e,i.memoizedState={element:r,isDehydrated:n,cache:null,transitions:null,pendingSuspenseBoundaries:null},qs(i),e}function J1(e,t,n){var r=3"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(gx)}catch(e){console.error(e)}}gx(),gf.exports=ot;var ov=gf.exports,Wu=ov;gl.createRoot=Wu.createRoot,gl.hydrateRoot=Wu.hydrateRoot;/** + * @remix-run/router v1.23.4 + * + * Copyright (c) Remix Software Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE.md file in the root directory of this source tree. + * + * @license MIT + */function ho(){return ho=Object.assign?Object.assign.bind():function(e){for(var t=1;t"u")throw new Error(t)}function Ex(e,t){if(!e){typeof console<"u"&&console.warn(t);try{throw new Error(t)}catch{}}}function lv(){return Math.random().toString(36).substr(2,8)}function Vu(e,t){return{usr:e.state,key:e.key,idx:t}}function ds(e,t,n,r){return n===void 0&&(n=null),ho({pathname:typeof e=="string"?e:e.pathname,search:"",hash:""},typeof t=="string"?gr(t):t,{state:n,key:t&&t.key||r||lv()})}function Cx(e){let{pathname:t="/",search:n="",hash:r=""}=e;return n&&n!=="?"&&(t+=n.charAt(0)==="?"?n:"?"+n),r&&r!=="#"&&(t+=r.charAt(0)==="#"?r:"#"+r),t}function gr(e){let t={};if(e){let n=e.indexOf("#");n>=0&&(t.hash=e.substr(n),e=e.substr(0,n));let r=e.indexOf("?");r>=0&&(t.search=e.substr(r),e=e.substr(0,r)),e&&(t.pathname=e)}return t}function sv(e,t,n,r){r===void 0&&(r={});let{window:o=document.defaultView,v5Compat:i=!1}=r,l=o.history,s=Zt.Pop,a=null,u=f();u==null&&(u=0,l.replaceState(ho({},l.state,{idx:u}),""));function f(){return(l.state||{idx:null}).idx}function d(){s=Zt.Pop;let E=f(),p=E==null?null:E-u;u=E,a&&a({action:s,location:g.location,delta:p})}function x(E,p){s=Zt.Push;let c=ds(g.location,E,p);u=f()+1;let h=Vu(c,u),v=g.createHref(c);try{l.pushState(h,"",v)}catch(w){if(w instanceof DOMException&&w.name==="DataCloneError")throw w;o.location.assign(v)}i&&a&&a({action:s,location:g.location,delta:1})}function m(E,p){s=Zt.Replace;let c=ds(g.location,E,p);u=f();let h=Vu(c,u),v=g.createHref(c);l.replaceState(h,"",v),i&&a&&a({action:s,location:g.location,delta:0})}function y(E){let p=o.location.origin!=="null"?o.location.origin:o.location.href,c=typeof E=="string"?E:Cx(E);return c=c.replace(/ $/,"%20"),Ce(p,"No window.location.(origin|href) available to create URL for href: "+c),new URL(c,p)}let g={get action(){return s},get location(){return e(o,l)},listen(E){if(a)throw new Error("A history only accepts one active listener");return o.addEventListener(qu,d),a=E,()=>{o.removeEventListener(qu,d),a=null}},createHref(E){return t(o,E)},createURL:y,encodeLocation(E){let p=y(E);return{pathname:p.pathname,search:p.search,hash:p.hash}},push:x,replace:m,go(E){return l.go(E)}};return g}var Ku;(function(e){e.data="data",e.deferred="deferred",e.redirect="redirect",e.error="error"})(Ku||(Ku={}));function av(e,t,n){return n===void 0&&(n="/"),uv(e,t,n)}function uv(e,t,n,r){let o=typeof t=="string"?gr(t):t,i=Sx(o.pathname||"/",n);if(i==null)return null;let l=wx(e);cv(l);let s=null,a=wv(i);for(let u=0;s==null&&u{let a={relativePath:s===void 0?i.path||"":s,caseSensitive:i.caseSensitive===!0,childrenIndex:l,route:i};a.relativePath.startsWith("/")&&(Ce(a.relativePath.startsWith(r),'Absolute route path "'+a.relativePath+'" nested under path '+('"'+r+'" is not valid. An absolute child route path ')+"must start with the combined path of all its parent routes."),a.relativePath=a.relativePath.slice(r.length));let u=An([r,a.relativePath]),f=n.concat(a);i.children&&i.children.length>0&&(Ce(i.index!==!0,"Index routes must not have child routes. Please remove "+('all child routes from route path "'+u+'".')),wx(i.children,t,f,u)),!(i.path==null&&!i.index)&&t.push({path:u,score:mv(u,i.index),routesMeta:f})};return e.forEach((i,l)=>{var s;if(i.path===""||!((s=i.path)!=null&&s.includes("?")))o(i,l);else for(let a of Bx(i.path))o(i,l,a)}),t}function Bx(e){let t=e.split("/");if(t.length===0)return[];let[n,...r]=t,o=n.endsWith("?"),i=n.replace(/\?$/,"");if(r.length===0)return o?[i,""]:[i];let l=Bx(r.join("/")),s=[];return s.push(...l.map(a=>a===""?i:[i,a].join("/"))),o&&s.push(...l),s.map(a=>e.startsWith("/")&&a===""?"/":a)}function cv(e){e.sort((t,n)=>t.score!==n.score?n.score-t.score:yv(t.routesMeta.map(r=>r.childrenIndex),n.routesMeta.map(r=>r.childrenIndex)))}const fv=/^:[\w-]+$/,dv=3,xv=2,pv=1,hv=10,vv=-2,Qu=e=>e==="*";function mv(e,t){let n=e.split("/"),r=n.length;return n.some(Qu)&&(r+=vv),t&&(r+=xv),n.filter(o=>!Qu(o)).reduce((o,i)=>o+(fv.test(i)?dv:i===""?pv:hv),r)}function yv(e,t){return e.length===t.length&&e.slice(0,-1).every((r,o)=>r===t[o])?e[e.length-1]-t[t.length-1]:0}function gv(e,t,n){let{routesMeta:r}=e,o={},i="/",l=[];for(let s=0;s{let{paramName:x,isOptional:m}=f;if(x==="*"){let g=s[d]||"";l=i.slice(0,i.length-g.length).replace(/(.)\/+$/,"$1")}const y=s[d];return m&&!y?u[x]=void 0:u[x]=(y||"").replace(/%2F/g,"/"),u},{}),pathname:i,pathnameBase:l,pattern:e}}function Cv(e,t,n){t===void 0&&(t=!1),n===void 0&&(n=!0),Ex(e==="*"||!e.endsWith("*")||e.endsWith("/*"),'Route path "'+e+'" will be treated as if it were '+('"'+e.replace(/\*$/,"/*")+'" because the `*` character must ')+"always follow a `/` in the pattern. To get rid of this warning, "+('please change the route path to "'+e.replace(/\*$/,"/*")+'".'));let r=[],o="^"+e.replace(/\/*\*?$/,"").replace(/^\/*/,"/").replace(/[\\.*+^${}|()[\]]/g,"\\$&").replace(/\/:([\w-]+)(\?)?/g,(l,s,a)=>(r.push({paramName:s,isOptional:a!=null}),a?"/?([^\\/]+)?":"/([^\\/]+)"));return e.endsWith("*")?(r.push({paramName:"*"}),o+=e==="*"||e==="/*"?"(.*)$":"(?:\\/(.+)|\\/*)$"):n?o+="\\/*$":e!==""&&e!=="/"&&(o+="(?:(?=\\/|$))"),[new RegExp(o,t?void 0:"i"),r]}function wv(e){try{return e.split("/").map(t=>decodeURIComponent(t).replace(/\//g,"%2F")).join("/")}catch(t){return Ex(!1,'The URL path "'+e+'" could not be decoded because it is is a malformed URL segment. This is probably due to a bad percent '+("encoding ("+t+").")),e}}function Sx(e,t){if(t==="/")return e;if(!e.toLowerCase().startsWith(t.toLowerCase()))return null;let n=t.endsWith("/")?t.length-1:t.length,r=e.charAt(n);return r&&r!=="/"?null:e.slice(n)||"/"}function Bv(e,t){t===void 0&&(t="/");let{pathname:n,search:r="",hash:o=""}=typeof e=="string"?gr(e):e,i;return n?(n=Dx(n),n.startsWith("/")?i=Xu(n.substring(1),"/"):i=Xu(n,t)):i=t,{pathname:i,search:_v(r),hash:Dv(o)}}function Xu(e,t){let n=t.replace(/\/+$/,"").split("/");return e.split("/").forEach(o=>{o===".."?n.length>1&&n.pop():o!=="."&&n.push(o)}),n.length>1?n.join("/"):"/"}function R0(e,t,n,r){return"Cannot include a '"+e+"' character in a manually specified "+("`to."+t+"` field ["+JSON.stringify(r)+"]. Please separate it out to the ")+("`to."+n+"` field. Alternatively you may provide the full path as ")+'a string in and the router will parse it for you.'}function Sv(e){return e.filter((t,n)=>n===0||t.route.path&&t.route.path.length>0)}function Ax(e,t){let n=Sv(e);return t?n.map((r,o)=>o===n.length-1?r.pathname:r.pathnameBase):n.map(r=>r.pathnameBase)}function _x(e,t,n,r){r===void 0&&(r=!1);let o;typeof e=="string"?o=gr(e):(o=ho({},e),Ce(!o.pathname||!o.pathname.includes("?"),R0("?","pathname","search",o)),Ce(!o.pathname||!o.pathname.includes("#"),R0("#","pathname","hash",o)),Ce(!o.search||!o.search.includes("#"),R0("#","search","hash",o)));let i=e===""||o.pathname==="",l=i?"/":o.pathname,s;if(l==null)s=n;else{let d=t.length-1;if(!r&&l.startsWith("..")){let x=l.split("/");for(;x[0]==="..";)x.shift(),d-=1;o.pathname=x.join("/")}s=d>=0?t[d]:"/"}let a=Bv(o,s),u=l&&l!=="/"&&l.endsWith("/"),f=(i||l===".")&&n.endsWith("/");return!a.pathname.endsWith("/")&&(u||f)&&(a.pathname+="/"),a}const Dx=e=>e.replace(/\/\/+/g,"/"),An=e=>Dx(e.join("/")),Av=e=>e.replace(/\/+$/,"").replace(/^\/*/,"/"),_v=e=>!e||e==="?"?"":e.startsWith("?")?e:"?"+e,Dv=e=>!e||e==="#"?"":e.startsWith("#")?e:"#"+e;function Fv(e){return e!=null&&typeof e.status=="number"&&typeof e.statusText=="string"&&typeof e.internal=="boolean"&&"data"in e}const Fx=["post","put","patch","delete"];new Set(Fx);const kv=["get",...Fx];new Set(kv);/** + * React Router v6.30.6 + * + * Copyright (c) Remix Software Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE.md file in the root directory of this source tree. + * + * @license MIT + */function vo(){return vo=Object.assign?Object.assign.bind():function(e){for(var t=1;t{s.current=!0}),z.useCallback(function(u,f){if(f===void 0&&(f={}),!s.current)return;if(typeof u=="number"){r.go(u);return}let d=_x(u,JSON.parse(l),i,f.relative==="path");e==null&&t!=="/"&&(d.pathname=d.pathname==="/"?t:An([t,d.pathname])),(f.replace?r.replace:r.push)(d,f.state,f)},[t,r,l,i,e])}function Ov(e,t){return jv(e,t)}function jv(e,t,n,r){Ao()||Ce(!1);let{navigator:o}=z.useContext(So),{matches:i}=z.useContext(zn),l=i[i.length-1],s=l?l.params:{};l&&l.pathname;let a=l?l.pathnameBase:"/";l&&l.route;let u=_o(),f;if(t){var d;let E=typeof t=="string"?gr(t):t;a==="/"||(d=E.pathname)!=null&&d.startsWith(a)||Ce(!1),f=E}else f=u;let x=f.pathname||"/",m=x;if(a!=="/"){let E=a.replace(/^\//,"").split("/");m="/"+x.replace(/^\//,"").split("/").slice(E.length).join("/")}let y=av(e,{pathname:m}),g=bv(y&&y.map(E=>Object.assign({},E,{params:Object.assign({},s,E.params),pathname:An([a,o.encodeLocation?o.encodeLocation(E.pathname).pathname:E.pathname]),pathnameBase:E.pathnameBase==="/"?a:An([a,o.encodeLocation?o.encodeLocation(E.pathnameBase).pathname:E.pathnameBase])})),i,n,r);return t&&g?z.createElement(Ji.Provider,{value:{location:vo({pathname:"/",search:"",hash:"",state:null,key:"default"},f),navigationType:Zt.Pop}},g):g}function Nv(){let e=Mv(),t=Fv(e)?e.status+" "+e.statusText:e instanceof Error?e.message:JSON.stringify(e),n=e instanceof Error?e.stack:null,o={padding:"0.5rem",backgroundColor:"rgba(200,200,200, 0.5)"};return z.createElement(z.Fragment,null,z.createElement("h2",null,"Unexpected Application Error!"),z.createElement("h3",{style:{fontStyle:"italic"}},t),n?z.createElement("pre",{style:o},n):null,null)}const Tv=z.createElement(Nv,null);class Lv extends z.Component{constructor(t){super(t),this.state={location:t.location,revalidation:t.revalidation,error:t.error}}static getDerivedStateFromError(t){return{error:t}}static getDerivedStateFromProps(t,n){return n.location!==t.location||n.revalidation!=="idle"&&t.revalidation==="idle"?{error:t.error,location:t.location,revalidation:t.revalidation}:{error:t.error!==void 0?t.error:n.error,location:n.location,revalidation:t.revalidation||n.revalidation}}componentDidCatch(t,n){console.error("React Router caught the following error during render",t,n)}render(){return this.state.error!==void 0?z.createElement(zn.Provider,{value:this.props.routeContext},z.createElement(kx.Provider,{value:this.state.error,children:this.props.component})):this.props.children}}function zv(e){let{routeContext:t,match:n,children:r}=e,o=z.useContext(da);return o&&o.static&&o.staticContext&&(n.route.errorElement||n.route.ErrorBoundary)&&(o.staticContext._deepestRenderedBoundaryId=n.route.id),z.createElement(zn.Provider,{value:t},r)}function bv(e,t,n,r){var o;if(t===void 0&&(t=[]),n===void 0&&(n=null),r===void 0&&(r=null),e==null){var i;if(!n)return null;if(n.errors)e=n.matches;else if((i=r)!=null&&i.v7_partialHydration&&t.length===0&&!n.initialized&&n.matches.length>0)e=n.matches;else return null}let l=e,s=(o=n)==null?void 0:o.errors;if(s!=null){let f=l.findIndex(d=>d.route.id&&(s==null?void 0:s[d.route.id])!==void 0);f>=0||Ce(!1),l=l.slice(0,Math.min(l.length,f+1))}let a=!1,u=-1;if(n&&r&&r.v7_partialHydration)for(let f=0;f=0?l=l.slice(0,u+1):l=[l[0]];break}}}return l.reduceRight((f,d,x)=>{let m,y=!1,g=null,E=null;n&&(m=s&&d.route.id?s[d.route.id]:void 0,g=d.route.errorElement||Tv,a&&(u<0&&x===0?(Wv("route-fallback"),y=!0,E=null):u===x&&(y=!0,E=d.route.hydrateFallbackElement||null)));let p=t.concat(l.slice(0,x+1)),c=()=>{let h;return m?h=g:y?h=E:d.route.Component?h=z.createElement(d.route.Component,null):d.route.element?h=d.route.element:h=f,z.createElement(zv,{match:d,routeContext:{outlet:f,matches:p,isDataRoute:n!=null},children:h})};return n&&(d.route.ErrorBoundary||d.route.errorElement||x===0)?z.createElement(Lv,{location:n.location,revalidation:n.revalidation,component:g,error:m,children:c(),routeContext:{outlet:null,matches:p,isDataRoute:!0}}):c()},null)}var Px=function(e){return e.UseBlocker="useBlocker",e.UseRevalidator="useRevalidator",e.UseNavigateStable="useNavigate",e}(Px||{}),Ox=function(e){return e.UseBlocker="useBlocker",e.UseLoaderData="useLoaderData",e.UseActionData="useActionData",e.UseRouteError="useRouteError",e.UseNavigation="useNavigation",e.UseRouteLoaderData="useRouteLoaderData",e.UseMatches="useMatches",e.UseRevalidator="useRevalidator",e.UseNavigateStable="useNavigate",e.UseRouteId="useRouteId",e}(Ox||{});function Iv(e){let t=z.useContext(da);return t||Ce(!1),t}function Uv(e){let t=z.useContext(Rv);return t||Ce(!1),t}function Hv(e){let t=z.useContext(zn);return t||Ce(!1),t}function jx(e){let t=Hv(),n=t.matches[t.matches.length-1];return n.route.id||Ce(!1),n.route.id}function Mv(){var e;let t=z.useContext(kx),n=Uv(),r=jx();return t!==void 0?t:(e=n.errors)==null?void 0:e[r]}function $v(){let{router:e}=Iv(Px.UseNavigateStable),t=jx(Ox.UseNavigateStable),n=z.useRef(!1);return Rx(()=>{n.current=!0}),z.useCallback(function(o,i){i===void 0&&(i={}),n.current&&(typeof o=="number"?e.navigate(o):e.navigate(o,vo({fromRouteId:t},i)))},[e,t])}const Gu={};function Wv(e,t,n){Gu[e]||(Gu[e]=!0)}function qv(e,t){e==null||e.v7_startTransition,e==null||e.v7_relativeSplatPath}function Vv(e){let{to:t,replace:n,state:r,relative:o}=e;Ao()||Ce(!1);let{future:i,static:l}=z.useContext(So),{matches:s}=z.useContext(zn),{pathname:a}=_o(),u=xa(),f=_x(t,Ax(s,i.v7_relativeSplatPath),a,o==="path"),d=JSON.stringify(f);return z.useEffect(()=>u(JSON.parse(d),{replace:n,state:r,relative:o}),[u,d,o,n,r]),null}function _t(e){Ce(!1)}function Kv(e){let{basename:t="/",children:n=null,location:r,navigationType:o=Zt.Pop,navigator:i,static:l=!1,future:s}=e;Ao()&&Ce(!1);let a=t.replace(/^\/*/,"/"),u=z.useMemo(()=>({basename:a,navigator:i,static:l,future:vo({v7_relativeSplatPath:!1},s)}),[a,s,i,l]);typeof r=="string"&&(r=gr(r));let{pathname:f="/",search:d="",hash:x="",state:m=null,key:y="default"}=r,g=z.useMemo(()=>{let E=Sx(f,a);return E==null?null:{location:{pathname:E,search:d,hash:x,state:m,key:y},navigationType:o}},[a,f,d,x,m,y,o]);return g==null?null:z.createElement(So.Provider,{value:u},z.createElement(Ji.Provider,{children:n,value:g}))}function Qv(e){let{children:t,location:n}=e;return Ov(xs(t),n)}new Promise(()=>{});function xs(e,t){t===void 0&&(t=[]);let n=[];return z.Children.forEach(e,(r,o)=>{if(!z.isValidElement(r))return;let i=[...t,o];if(r.type===z.Fragment){n.push.apply(n,xs(r.props.children,i));return}r.type!==_t&&Ce(!1),!r.props.index||!r.props.children||Ce(!1);let l={id:r.props.id||i.join("-"),caseSensitive:r.props.caseSensitive,element:r.props.element,Component:r.props.Component,index:r.props.index,path:r.props.path,loader:r.props.loader,action:r.props.action,errorElement:r.props.errorElement,ErrorBoundary:r.props.ErrorBoundary,hasErrorBoundary:r.props.ErrorBoundary!=null||r.props.errorElement!=null,shouldRevalidate:r.props.shouldRevalidate,handle:r.props.handle,lazy:r.props.lazy};r.props.children&&(l.children=xs(r.props.children,i)),n.push(l)}),n}/** + * React Router DOM v6.30.6 + * + * Copyright (c) Remix Software Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE.md file in the root directory of this source tree. + * + * @license MIT + */const Xv="6";try{window.__reactRouterVersion=Xv}catch{}const Gv="startTransition",Yu=Kp[Gv];function Yv(e){let{basename:t,children:n,future:r,window:o}=e,i=z.useRef();i.current==null&&(i.current=iv({window:o,v5Compat:!0}));let l=i.current,[s,a]=z.useState({action:l.action,location:l.location}),{v7_startTransition:u}=r||{},f=z.useCallback(d=>{u&&Yu?Yu(()=>a(d)):a(d)},[a,u]);return z.useLayoutEffect(()=>l.listen(f),[l,f]),z.useEffect(()=>qv(r),[r]),z.createElement(Kv,{basename:t,children:n,location:s.location,navigationType:s.action,navigator:l,future:r})}var Zu;(function(e){e.UseScrollRestoration="useScrollRestoration",e.UseSubmit="useSubmit",e.UseSubmitFetcher="useSubmitFetcher",e.UseFetcher="useFetcher",e.useViewTransitionState="useViewTransitionState"})(Zu||(Zu={}));var Ju;(function(e){e.UseFetcher="useFetcher",e.UseFetchers="useFetchers",e.UseScrollRestoration="useScrollRestoration"})(Ju||(Ju={}));function Nx(e,t){return function(){return e.apply(t,arguments)}}const{toString:Zv}=Object.prototype,{getPrototypeOf:cn}=Object,{iterator:Do,toStringTag:Tx}=Symbol,mo=(({hasOwnProperty:e})=>(t,n)=>e.call(t,n))(Object.prototype),Lx=e=>typeof e=="string"&&(e==="__proto__"||e==="constructor"||e==="prototype"),zx=(e,t,n)=>e===Object.prototype||!n&&t===null,Jv=e=>{if(!Object.isExtensible(e))return!1;const t=Object.getOwnPropertyNames(e);return Object.getOwnPropertySymbols&&t.push(...Object.getOwnPropertySymbols(e)),t.every(n=>{if(Lx(n))return!1;const r=Object.getOwnPropertyDescriptor(e,n);return!!r&&r.configurable&&r.writable===!0})},yo=(e,t)=>{let n=e;const r=[];for(;n!=null;){if(r.indexOf(n)!==-1)return!1;r.push(n);const o=cn(n);if(zx(n,o,n===e))return!1;if(mo(n,t))return!0;n=o}return!1},em=(e,t)=>e!=null&&yo(e,t)?e[t]:void 0,tm=e=>{if(e==null||typeof e!="object"&&typeof e!="function")return e;const t=cn(e);if(t===null&&Jv(e))return e;const n=Object.create(null),r=Object.create(null),o=[];let i=e;for(;i!=null&&o.indexOf(i)===-1;){o.push(i);const l=i===e?t:cn(i);if(zx(i,l,i===e))break;const s=Object.getOwnPropertyNames(i);Object.getOwnPropertySymbols&&s.push(...Object.getOwnPropertySymbols(i));for(const a of s)Lx(a)||mo(r,a)||(n[a]=e[a],r[a]=!0);i=l}return n},pa=(e=>t=>{const n=Zv.call(t);return e[n]||(e[n]=n.slice(8,-1).toLowerCase())})(Object.create(null)),xt=e=>(e=e.toLowerCase(),t=>pa(t)===e),e0=e=>t=>typeof t===e,{isArray:On}=Array,jn=e0("undefined");function Er(e){return e!==null&&!jn(e)&&e.constructor!==null&&!jn(e.constructor)&&Ze(e.constructor.isBuffer)&&e.constructor.isBuffer(e)}const bx=xt("ArrayBuffer");function nm(e){let t;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?t=ArrayBuffer.isView(e):t=e&&e.buffer&&bx(e.buffer),t}const rm=e0("string"),Ze=e0("function"),Ix=e0("number"),Cr=e=>e!==null&&typeof e=="object",om=e=>e===!0||e===!1,si=e=>{if(!Cr(e))return!1;const t=cn(e);return(t===null||t===Object.prototype||cn(t)===null)&&!yo(e,Tx)&&!yo(e,Do)},im=e=>{if(!Cr(e)||Er(e))return!1;try{return Object.keys(e).length===0&&Object.getPrototypeOf(e)===Object.prototype}catch{return!1}},lm=xt("Date"),sm=xt("File"),am=e=>!!(e&&typeof e.uri<"u"),um=e=>e&&typeof e.getParts<"u",cm=xt("Blob"),fm=xt("FileList"),dm=xt("Set"),xm=e=>Cr(e)&&Ze(e.pipe);function pm(){return typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{}}const ec=pm(),tc=typeof ec.FormData<"u"?ec.FormData:void 0,hm=e=>{if(!e)return!1;if(tc&&e instanceof tc)return!0;const t=cn(e);if(!t||t===Object.prototype||!Ze(e.append))return!1;const n=pa(e);return n==="formdata"||n==="object"&&Ze(e.toString)&&e.toString()==="[object FormData]"},vm=xt("URLSearchParams"),[mm,ym,gm,Em]=["ReadableStream","Request","Response","Headers"].map(xt),Cm=e=>e.trim?e.trim():e.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"");function Fo(e,t,{allOwnKeys:n=!1}={}){if(e===null||typeof e>"u")return;let r,o;if(typeof e!="object"&&(e=[e]),On(e))for(r=0,o=e.length;r0;)if(o=n[r],t===o.toLowerCase())return o;return null}const wn=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,Hx=e=>!jn(e)&&e!==wn;function ps(...e){const{caseless:t,skipUndefined:n}=Hx(this)&&this||{},r={},o=(i,l)=>{if(l==="__proto__"||l==="constructor"||l==="prototype")return;const s=t&&typeof l=="string"&&Ux(r,l)||l,a=mo(r,s)?r[s]:void 0;si(a)&&si(i)?r[s]=ps(a,i):si(i)?r[s]=ps({},i):On(i)?r[s]=i.slice():(!n||!jn(i))&&(r[s]=i)};for(let i=0,l=e.length;i(Fo(t,(o,i)=>{n&&Ze(o)?Object.defineProperty(e,i,{__proto__:null,value:Nx(o,n),writable:!0,enumerable:!0,configurable:!0}):Object.defineProperty(e,i,{__proto__:null,value:o,writable:!0,enumerable:!0,configurable:!0})},{allOwnKeys:r}),e),Bm=e=>(e.charCodeAt(0)===65279&&(e=e.slice(1)),e),Sm=(e,t,n,r)=>{e.prototype=Object.create(t.prototype,r),Object.defineProperty(e.prototype,"constructor",{__proto__:null,value:e,writable:!0,enumerable:!1,configurable:!0}),Object.defineProperty(e,"super",{__proto__:null,value:t.prototype}),n&&Object.assign(e.prototype,n)},Am=(e,t,n,r)=>{let o,i,l;const s={};if(t=t||{},e==null)return t;do{for(o=Object.getOwnPropertyNames(e),i=o.length;i-- >0;)l=o[i],(!r||r(l,e,t))&&!s[l]&&(t[l]=e[l],s[l]=!0);e=n!==!1&&cn(e)}while(e&&(!n||n(e,t))&&e!==Object.prototype);return t},_m=(e,t,n)=>{e=String(e),(n===void 0||n>e.length)&&(n=e.length),n-=t.length;const r=e.indexOf(t,n);return r!==-1&&r===n},Dm=e=>{if(!e)return null;if(On(e))return e;let t=e.length;if(!Ix(t))return null;const n=new Array(t);for(;t-- >0;)n[t]=e[t];return n},Fm=(e=>t=>e&&t instanceof e)(typeof Uint8Array<"u"&&cn(Uint8Array)),km=(e,t)=>{const r=(e&&e[Do]).call(e);let o;for(;(o=r.next())&&!o.done;){const i=o.value;t.call(e,i[0],i[1])}},Rm=(e,t)=>{let n;const r=[];for(;(n=e.exec(t))!==null;)r.push(n);return r},Pm=xt("HTMLFormElement"),Om=e=>e.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,function(n,r,o){return r.toUpperCase()+o}),{propertyIsEnumerable:jm}=Object.prototype,Nm=xt("RegExp"),Mx=(e,t)=>{const n=Object.getOwnPropertyDescriptors(e),r={};Fo(n,(o,i)=>{let l;(l=t(o,i,e))!==!1&&(r[i]=l||o)}),Object.defineProperties(e,r)},Tm=e=>{Mx(e,(t,n)=>{if(Ze(e)&&["arguments","caller","callee"].includes(n))return!1;const r=e[n];if(Ze(r)){if(t.enumerable=!1,"writable"in t){t.writable=!1;return}t.set||(t.set=()=>{throw Error("Can not rewrite read-only method '"+n+"'")})}})},Lm=(e,t)=>{const n={},r=o=>{o.forEach(i=>{n[i]=!0})};return On(e)?r(e):r(String(e).split(t)),n},zm=()=>{},bm=(e,t)=>e!=null&&Number.isFinite(e=+e)?e:t;function Im(e){return!!(e&&Ze(e.append)&&e[Tx]==="FormData"&&e[Do])}const Um=e=>{const t=new WeakSet,n=r=>{if(Cr(r)){if(t.has(r))return;if(Er(r))return r;if(!("toJSON"in r)){t.add(r);let o;if(dm(r)){o=[];for(const i of r){const l=n(i);!jn(l)&&o.push(l)}}else o=On(r)?[]:{},Fo(r,(i,l)=>{const s=n(i);!jn(s)&&(o[l]=s)});return t.delete(r),o}}return r};return n(e)},Hm=xt("AsyncFunction"),Mm=e=>e&&(Cr(e)||Ze(e))&&Ze(e.then)&&Ze(e.catch),$x=((e,t)=>e?setImmediate:t?((n,r)=>(wn.addEventListener("message",({source:o,data:i})=>{o===wn&&i===n&&r.length&&r.shift()()},!1),o=>{r.push(o),wn.postMessage(n,"*")}))(`axios@${Math.random()}`,[]):n=>setTimeout(n))(typeof setImmediate=="function",Ze(wn.postMessage)),$m=typeof queueMicrotask<"u"?queueMicrotask.bind(wn):typeof process<"u"&&process.nextTick||$x,Wx=e=>e!=null&&Ze(e[Do]),Wm=e=>e!=null&&yo(e,Do)&&Wx(e),_={isArray:On,isArrayBuffer:bx,isBuffer:Er,isFormData:hm,isArrayBufferView:nm,isString:rm,isNumber:Ix,isBoolean:om,isObject:Cr,isPlainObject:si,isEmptyObject:im,isReadableStream:mm,isRequest:ym,isResponse:gm,isHeaders:Em,isUndefined:jn,isDate:lm,isFile:sm,isReactNativeBlob:am,isReactNative:um,isBlob:cm,isRegExp:Nm,isFunction:Ze,isStream:xm,isURLSearchParams:vm,isTypedArray:Fm,isFileList:fm,forEach:Fo,merge:ps,extend:wm,trim:Cm,stripBOM:Bm,inherits:Sm,toFlatObject:Am,kindOf:pa,kindOfTest:xt,endsWith:_m,toArray:Dm,forEachEntry:km,matchAll:Rm,isHTMLForm:Pm,hasOwnProperty:mo,hasOwnProp:mo,hasOwnInPrototypeChain:yo,getSafeProp:em,toSafeFlatObject:tm,reduceDescriptors:Mx,freezeMethods:Tm,toObjectSet:Lm,toCamelCase:Om,noop:zm,toFiniteNumber:bm,findKey:Ux,global:wn,isContextDefined:Hx,isSpecCompliantForm:Im,toJSONObject:Um,isAsyncFn:Hm,isThenable:Mm,setImmediate:$x,asap:$m,isIterable:Wx,isSafeIterable:Wm},qm=_.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),Vm=e=>{const t={};let n,r,o;return e&&e.split(` +`).forEach(function(l){o=l.indexOf(":"),n=l.substring(0,o).trim().toLowerCase(),r=l.substring(o+1).trim();const s=_.hasOwnProp(t,n);!n||s&&_.hasOwnProp(qm,n)||(n==="set-cookie"?s?t[n].push(r):t[n]=[r]:t[n]=s?t[n]+", "+r:r)}),t};function Km(e){let t=0,n=e.length;for(;tt;){const r=e.charCodeAt(n-1);if(r!==9&&r!==32)break;n-=1}return t===0&&n===e.length?e:e.slice(t,n)}const Qm=new RegExp("[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+","g"),Xm=new RegExp("[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+","g");function ha(e,t){return _.isArray(e)?e.map(n=>ha(n,t)):Km(String(e).replace(t,""))}const Gm=e=>ha(e,Qm),Ym=e=>ha(e,Xm);function qx(e){const t=Object.create(null);return _.forEach(e.toJSON(),(n,r)=>{t[r]=Ym(n)}),t}const nc=Symbol("internals");function Tr(e){return e&&String(e).trim().toLowerCase()}function ai(e){return e===!1||e==null?e:_.isArray(e)?e.map(ai):Gm(String(e))}function Zm(e){const t=Object.create(null),n=/([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;let r;for(;r=n.exec(e);)t[r[1]]=r[2];return t}const Jm=/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;function P0(e){let t=0,n=e.length;for(;tt;){const r=e.charCodeAt(n-1);if(r!==9&&r!==32)break;n-=1}return t===0&&n===e.length?e:e.slice(t,n)}function e2(e){const t=e.length-1;if(t<1||e.charCodeAt(0)!==34||e.charCodeAt(t)!==34)return e;let n="";for(let r=1;r=t))return e;n+=e[r]}return n}function t2(e){const t=Object.create(null),n=String(e);let r=0,o=!1,i=!1;function l(s){const a=P0(n.slice(r,s)),u=a.indexOf("=");if(u<1)return;const f=P0(a.slice(0,u));if(!Jm.test(f))return;const d=f.toLowerCase();if(d==="__proto__"||d==="constructor"||d==="prototype")return;const x=P0(a.slice(u+1));t[d]=e2(x)}for(let s=0;s/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(e.trim());function O0(e,t,n,r,o){if(_.isFunction(r))return r.call(this,t,n);if(o&&(t=n),!!_.isString(t)){if(_.isString(r))return t.indexOf(r)!==-1;if(_.isRegExp(r))return r.test(t)}}function r2(e){return e.trim().toLowerCase().replace(/([a-z\d])(\w*)/g,(t,n,r)=>n.toUpperCase()+r)}function o2(e,t){const n=_.toCamelCase(" "+t);["get","set","has"].forEach(r=>{Object.defineProperty(e,r+n,{__proto__:null,value:function(o,i,l){return this[r].call(this,t,o,i,l)},configurable:!0})})}let ze=class{constructor(t){t&&this.set(t)}set(t,n,r){const o=this;function i(s,a,u){const f=Tr(a);if(!f)return;const d=_.findKey(o,f);(!d||o[d]===void 0||u===!0||u===void 0&&o[d]!==!1)&&(o[d||a]=ai(s))}const l=(s,a)=>_.forEach(s,(u,f)=>i(u,f,a));if(_.isPlainObject(t)||t instanceof this.constructor)l(t,n);else if(_.isString(t)&&(t=t.trim())&&!n2(t))l(Vm(t),n);else if(_.isObject(t)&&_.isSafeIterable(t)){let s=Object.create(null),a,u;for(const f of t){if(!_.isArray(f))throw new TypeError("Object iterator must return a key-value pair");u=f[0],_.hasOwnProp(s,u)?(a=s[u],s[u]=_.isArray(a)?[...a,f[1]]:[a,f[1]]):s[u]=f[1]}l(s,n)}else t!=null&&i(n,t,r);return this}get(t,n){if(t=Tr(t),t){const r=_.findKey(this,t);if(r){const o=this[r];if(!n)return o;if(n===!0)return Zm(o);if(_.isFunction(n))return n.call(this,o,r);if(_.isRegExp(n))return n.exec(o);throw new TypeError("parser must be boolean|regexp|function")}}}has(t,n){if(t=Tr(t),t){const r=_.findKey(this,t);return!!(r&&this[r]!==void 0&&(!n||O0(this,this[r],r,n)))}return!1}delete(t,n){const r=this;let o=!1;function i(l){if(l=Tr(l),l){const s=_.findKey(r,l);s&&(!n||O0(r,r[s],s,n))&&(delete r[s],o=!0)}}return _.isArray(t)?t.forEach(i):i(t),o}clear(t){const n=Object.keys(this);let r=n.length,o=!1;for(;r--;){const i=n[r];(!t||O0(this,this[i],i,t,!0))&&(delete this[i],o=!0)}return o}normalize(t){const n=this,r={};return _.forEach(this,(o,i)=>{const l=_.findKey(r,i);if(l){n[l]=ai(o),delete n[i];return}const s=t?r2(i):String(i).trim();s!==i&&delete n[i],n[s]=ai(o),r[s]=!0}),this}concat(...t){return this.constructor.concat(this,...t)}toJSON(t){const n=Object.create(null);return _.forEach(this,(r,o)=>{r!=null&&r!==!1&&(n[o]=t&&_.isArray(r)?r.join(", "):r)}),n}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([t,n])=>t+": "+n).join(` +`)}getSetCookie(){const t=this.get("set-cookie");return _.isArray(t)?t:t==null||t===!1?[]:[t]}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(t){return t instanceof this?t:new this(t)}static parseParameters(t){return t2(t)}static concat(t,...n){const r=new this(t);return n.forEach(o=>r.set(o)),r}static accessor(t){const r=(this[nc]=this[nc]={accessors:{}}).accessors,o=this.prototype;function i(l){const s=Tr(l);r[s]||(o2(o,l),r[s]=!0)}return _.isArray(t)?t.forEach(i):i(t),this}};ze.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);_.reduceDescriptors(ze.prototype,({value:e},t)=>{let n=t[0].toUpperCase()+t.slice(1);return{get:()=>e,set(r){this[n]=r}}});_.freezeMethods(ze);const Ti="[REDACTED ****]";function i2(e){if(_.hasOwnProp(e,"toJSON"))return!0;let t=Object.getPrototypeOf(e);for(;t&&t!==Object.prototype;){if(_.hasOwnProp(t,"toJSON"))return!0;t=Object.getPrototypeOf(t)}return!1}function l2(e,t){const n=new Set(t.map(i=>String(i).toLowerCase())),r=[],o=i=>{if(i===null||typeof i!="object"||_.isBuffer(i))return i;if(r.indexOf(i)!==-1)return;i instanceof ze&&(i=i.toJSON()),r.push(i);let l;if(_.isArray(i))l=[],i.forEach((s,a)=>{const u=o(s);_.isUndefined(u)||(l[a]=u)});else{if(!_.isPlainObject(i)&&i2(i))return r.pop(),i;l=Object.create(null);for(const[s,a]of Object.entries(i)){const u=n.has(s.toLowerCase())?Ti:o(a);_.isUndefined(u)||(l[s]=u)}}return r.pop(),l};return o(e)}function rc(e){try{return String(e)}catch{return""}}function s2(e){return e.errors.map(n=>{try{return n&&n.message?rc(n.message):rc(n)}catch{return""}}).filter(Boolean).join("; ")||e.name||"AggregateError"}let I=class Vx extends Error{static from(t,n,r,o,i,l){let s=t.message;!s&&_.isArray(t.errors)&&t.errors.length&&(s=s2(t));const a=new Vx(s,n||t.code,r,o,i);return Object.defineProperty(a,"cause",{__proto__:null,value:t,writable:!0,enumerable:!1,configurable:!0}),a.name=t.name,t.status!=null&&a.status==null&&(a.status=t.status),l&&Object.assign(a,l),a}constructor(t,n,r,o,i){super(t),Object.defineProperty(this,"message",{__proto__:null,value:t,enumerable:!0,writable:!0,configurable:!0}),this.name="AxiosError",this.isAxiosError=!0,n&&(this.code=n),r&&(this.config=r),o&&(this.request=o),i&&(this.response=i,this.status=i.status)}toJSON(){const t=this.config,n=t&&_.hasOwnProp(t,"redact")?t.redact:void 0,r=_.isArray(n)&&n.length>0?l2(t,n):_.toJSONObject(t);return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:r,code:this.code,status:this.status}}};I.ERR_BAD_OPTION_VALUE="ERR_BAD_OPTION_VALUE";I.ERR_BAD_OPTION="ERR_BAD_OPTION";I.ECONNABORTED="ECONNABORTED";I.ETIMEDOUT="ETIMEDOUT";I.ECONNREFUSED="ECONNREFUSED";I.ERR_NETWORK="ERR_NETWORK";I.ERR_FR_TOO_MANY_REDIRECTS="ERR_FR_TOO_MANY_REDIRECTS";I.ERR_DEPRECATED="ERR_DEPRECATED";I.ERR_BAD_RESPONSE="ERR_BAD_RESPONSE";I.ERR_BAD_REQUEST="ERR_BAD_REQUEST";I.ERR_CANCELED="ERR_CANCELED";I.ERR_NOT_SUPPORT="ERR_NOT_SUPPORT";I.ERR_INVALID_URL="ERR_INVALID_URL";I.ERR_FORM_DATA_DEPTH_EXCEEDED="ERR_FORM_DATA_DEPTH_EXCEEDED";const a2=null,Kx=100;function hs(e){return _.isPlainObject(e)||_.isArray(e)}function Qx(e){return _.endsWith(e,"[]")?e.slice(0,-2):e}function j0(e,t,n){return e?e.concat(t).map(function(o,i){return o=Qx(o),!n&&i?"["+o+"]":o}).join(n?".":""):t}function u2(e){return _.isArray(e)&&!e.some(hs)}const c2=_.toFlatObject(_,{},null,function(t){return/^is[A-Z]/.test(t)});function t0(e,t,n){if(!_.isObject(e))throw new TypeError("target must be an object");t=t||new FormData;const r=(c,h)=>{const v=_.getSafeProp(n,c);return _.isUndefined(v)?h:v},o=r("metaTokens",!0),i=r("visitor")||g,l=r("dots",!1),s=r("indexes",!1),a=r("Blob")||typeof Blob<"u"&&Blob,u=r("maxDepth",Kx),f=a&&_.isSpecCompliantForm(t),d=[];if(!_.isFunction(i))throw new TypeError("visitor must be a function");function x(c){if(c===null)return"";if(_.isDate(c))return c.toISOString();if(_.isBoolean(c))return c.toString();if(!f&&_.isBlob(c))throw new I("Blob is not supported. Use a Buffer instead.");if(_.isArrayBuffer(c)||_.isTypedArray(c)){if(f&&typeof a=="function")return new a([c]);throw new I("Blob is not supported. Use a Buffer instead.",I.ERR_NOT_SUPPORT)}return c}function m(c){if(c>u)throw new I("Object is too deeply nested ("+c+" levels). Max depth: "+u,I.ERR_FORM_DATA_DEPTH_EXCEEDED)}function y(c,h){if(u===1/0)return JSON.stringify(c);const v=[];return JSON.stringify(c,function(B,S){if(!_.isObject(S))return S;for(;v.length&&v[v.length-1]!==this;)v.pop();return v.push(S),m(h+v.length-1),S})}function g(c,h,v){let w=c;if(_.isReactNative(t)&&_.isReactNativeBlob(c))return t.append(j0(v,h,l),x(c)),!1;if(c&&!v&&typeof c=="object"){if(_.endsWith(h,"{}"))h=o?h:h.slice(0,-2),c=y(c,1);else if(_.isArray(c)&&u2(c)||(_.isFileList(c)||_.endsWith(h,"[]"))&&(w=_.toArray(c)))return h=Qx(h),w.forEach(function(S,D){!(_.isUndefined(S)||S===null)&&t.append(s===!0?j0([h],D,l):s===null?h:h+"[]",x(S))}),!1}return hs(c)?!0:(t.append(j0(v,h,l),x(c)),!1)}const E=Object.assign(c2,{defaultVisitor:g,convertValue:x,isVisitable:hs});function p(c,h,v=0){if(!_.isUndefined(c)){if(m(v),d.indexOf(c)!==-1)throw new Error("Circular reference detected in "+h.join("."));d.push(c),_.forEach(c,function(B,S){(!(_.isUndefined(B)||B===null)&&i.call(t,B,_.isString(S)?S.trim():S,h,E))===!0&&p(B,h?h.concat(S):[S],v+1)}),d.pop()}}if(!_.isObject(e))throw new TypeError("data must be an object");return p(e),t}function oc(e){const t={"!":"%21","'":"%27","(":"%28",")":"%29","~":"%7E","%20":"+"};return encodeURIComponent(e).replace(/[!'()~]|%20/g,function(r){return t[r]})}function va(e,t){this._pairs=[],e&&t0(e,this,t)}const Xx=va.prototype;Xx.append=function(t,n){this._pairs.push([t,n])};Xx.toString=function(t){const n=t?r=>t.call(this,r,oc):oc;return this._pairs.map(function(o){return n(o[0])+"="+n(o[1])},"").join("&")};function f2(e){return encodeURIComponent(e).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+")}function Gx(e,t,n){if(!t)return e;e=e||"";const r=_.isFunction(n)?{serialize:n}:n,o=_.getSafeProp(r,"encode")||f2,i=_.getSafeProp(r,"serialize");let l;if(i?l=i(t,r):l=_.isURLSearchParams(t)?t.toString():new va(t,r).toString(o),l){const s=e.indexOf("#");s!==-1&&(e=e.slice(0,s)),e+=(e.indexOf("?")===-1?"?":"&")+l}return e}const Lr=Symbol("internals");function Yx(e){return e?e.length:0}function ic(e){if(e)for(;e.length&&e[e.length-1]===null;)e.pop()}function zr(e,t){const n=e.handlers,r=Yx(n);n!==t.handlersRef?(t.handlersRef=n,t.handlerEntries.clear()):r!==t.handlersLength&&(r?t.handlerEntries.forEach(function(i,l){n[i.index]!==i.handler&&t.handlerEntries.delete(l)}):t.handlerEntries.clear()),t.handlersLength=r}class lc{constructor(){this.handlers=[],this[Lr]={handlersRef:this.handlers,handlersLength:this.handlers.length,handlerEntries:new Map,iterationDepth:0,nextId:0}}use(t,n,r){const o={fulfilled:t,rejected:n,synchronous:r?r.synchronous:!1,runWhen:r?r.runWhen:null},i=this[Lr];this.handlers==null&&(this.handlers=[]),zr(this,i);const l=i.nextId++;return this.handlers.push(o),i.handlerEntries.set(l,{handler:o,index:this.handlers.length-1}),i.handlersLength=this.handlers.length,l}eject(t){const n=this[Lr];zr(this,n);const r=n.handlerEntries.get(t);if(r){if(n.handlerEntries.delete(t),this.handlers[r.index]!==r.handler)return;this.handlers[r.index]=null,n.iterationDepth||(ic(this.handlers),n.handlersLength=this.handlers.length)}}clear(){this.handlers&&(this.handlers=[],zr(this,this[Lr]))}forEach(t){const n=this[Lr];zr(this,n),n.iterationDepth++;try{_.forEach(this.handlers,function(o){o!==null&&t(o)})}finally{--n.iterationDepth||(zr(this,n),ic(this.handlers),n.handlersLength=Yx(this.handlers))}}}const ma={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1,legacyInterceptorReqResOrdering:!0,advertiseZstdAcceptEncoding:!1,validateStatusUndefinedResolves:!0},d2=typeof URLSearchParams<"u"?URLSearchParams:va,x2=typeof FormData<"u"?FormData:null,p2=typeof Blob<"u"?Blob:null,h2={isBrowser:!0,classes:{URLSearchParams:d2,FormData:x2,Blob:p2},protocols:["http","https","file","blob","url","data"]},ya=typeof window<"u"&&typeof document<"u",vs=typeof navigator=="object"&&navigator||void 0,v2=ya&&(!vs||["ReactNative","NativeScript","NS"].indexOf(vs.product)<0),m2=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function",y2=ya&&window.location.href||"http://localhost",g2=Object.freeze(Object.defineProperty({__proto__:null,hasBrowserEnv:ya,hasStandardBrowserEnv:v2,hasStandardBrowserWebWorkerEnv:m2,navigator:vs,origin:y2},Symbol.toStringTag,{value:"Module"})),_e={...g2,...h2};function E2(e,t){return t0(e,new _e.classes.URLSearchParams,{visitor:function(n,r,o,i){return _e.isNode&&_.isBuffer(n)?(this.append(r,n.toString("base64")),!1):i.defaultVisitor.apply(this,arguments)},...t})}const sc=Kx;function Zx(e){if(e>sc)throw new I("FormData field is too deeply nested ("+e+" levels). Max depth: "+sc,I.ERR_FORM_DATA_DEPTH_EXCEEDED)}function C2(e){const t=[],n=/[^.[\]]+|\[([^.[\]]*)]/g;let r;for(;(r=n.exec(e))!==null;)Zx(t.length),t.push(r[0]==="[]"?"":r[1]||r[0]);return t}function w2(e){const t={},n=Object.keys(e);let r;const o=n.length;let i;for(r=0;r=n.length;return l=!l&&_.isArray(o)?o.length:l,a?(_.hasOwnProp(o,l)?o[l]=_.isArray(o[l])?o[l].concat(r):[o[l],r]:o[l]=r,!s):((!_.hasOwnProp(o,l)||!_.isObject(o[l]))&&(o[l]=[]),t(n,r,o[l],i)&&_.isArray(o[l])&&(o[l]=w2(o[l])),!s)}if(_.isFormData(e)&&_.isFunction(e.entries)){const n={};return _.forEachEntry(e,(r,o)=>{t(C2(r),o,n,0)}),n}return null}const ep=Object.freeze(["get","delete","head","options","post","put","patch","purge","link","unlink","query"]),Wn=(e,t)=>e!=null&&_.hasOwnProp(e,t)?e[t]:void 0;function B2(e,t,n){if(_.isString(e))try{return(t||JSON.parse)(e),_.trim(e)}catch(r){if(r.name!=="SyntaxError")throw r}return(n||JSON.stringify)(e)}const ko={transitional:ma,adapter:["xhr","http","fetch"],transformRequest:[function(t,n){const r=n.getContentType()||"",o=r.indexOf("application/json")>-1,i=_.isObject(t);if(i&&_.isHTMLForm(t)&&(t=new FormData(t)),_.isFormData(t))return o?JSON.stringify(Jx(t)):t;if(_.isArrayBuffer(t)||_.isBuffer(t)||_.isStream(t)||_.isFile(t)||_.isBlob(t)||_.isReadableStream(t))return t;if(_.isArrayBufferView(t))return t.buffer;if(_.isURLSearchParams(t))return n.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),t.toString();let s;if(i){const a=Wn(this,"formSerializer");if(r.indexOf("application/x-www-form-urlencoded")>-1)return E2(t,a).toString();if((s=_.isFileList(t))||r.indexOf("multipart/form-data")>-1){const u=Wn(this,"env"),f=u&&u.FormData;return t0(s?{"files[]":t}:t,f&&new f,a)}}return i||o?(n.setContentType("application/json",!1),B2(t)):t}],transformResponse:[function(t){const n=Wn(this,"transitional")||ko.transitional,r=n&&n.forcedJSONParsing,o=Wn(this,"responseType"),i=o==="json";if(_.isResponse(t)||_.isReadableStream(t))return t;if(t&&_.isString(t)&&(r&&!o||i)){const s=!(n&&n.silentJSONParsing)&&i;try{return JSON.parse(t,Wn(this,"parseReviver"))}catch(a){if(s)throw a.name==="SyntaxError"?I.from(a,I.ERR_BAD_RESPONSE,this,null,Wn(this,"response")):a}}return t}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:_e.classes.FormData,Blob:_e.classes.Blob},validateStatus:function(t){return t>=200&&t<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};_.forEach(ep,e=>{ko.headers[e]={}});function N0(e,t){const n=this||ko,r=t||n,o=ze.from(r.headers);let i=r.data;return _.forEach(e,function(s){i=s.call(n,i,o.normalize(),t?t.status:void 0)}),o.normalize(),i}function tp(e){return!!(e&&e.__CANCEL__)}let Ro=class extends I{constructor(t,n,r){super(t??"canceled",I.ERR_CANCELED,n,r),this.name="CanceledError",this.__CANCEL__=!0}};function np(e,t,n){const r=n.config.validateStatus;!n.status||!r||r(n.status)?e(n):t(new I("Request failed with status code "+n.status,n.status>=400&&n.status<500?I.ERR_BAD_REQUEST:I.ERR_BAD_RESPONSE,n.config,n.request,n))}const S2=/[\t\n\r]/g;function rp(e){if(typeof e!="string")return e;let t=0;for(;t{n=d,o=null,i&&(clearTimeout(i),i=null),e(...f)};return[(...f)=>{const d=Date.now(),x=d-n;x>=r?l(f,d):(o=f,i||(i=setTimeout(()=>{i=null,l(o)},r-x)))},()=>o&&l(o),(...f)=>l(f)]}const Li=(e,t,n=3)=>{let r=0;const o=A2(50,250);return _2(i=>{if(!i||!_.isNumber(i.loaded))return;const l=i.loaded,s=i.lengthComputable?i.total:void 0,a=Math.max(0,s!=null?Math.min(l,s):l),u=Math.max(0,a-r),f=o(u);r=Math.max(r,a);const d={loaded:a,total:s,progress:s?a/s:void 0,bytes:u,rate:f||void 0,estimated:f&&s?(s-a)/f:void 0,event:i,lengthComputable:s!=null,[t?"download":"upload"]:!0};e(d)},n)},ac=(e,t)=>{const n=e!=null;return[r=>t[0]({lengthComputable:n,total:e,loaded:r}),t[1]]},uc=(e,t=_.asap)=>(...n)=>t(()=>e(...n)),D2=_e.hasStandardBrowserEnv?((e,t)=>n=>(n=new URL(n,_e.origin),e.protocol===n.protocol&&e.host===n.host&&(t||e.port===n.port)))(new URL(_e.origin),_e.navigator&&/(msie|trident)/i.test(_e.navigator.userAgent)):()=>!0,F2=_e.hasStandardBrowserEnv?{write(e,t,n,r,o,i,l){if(typeof document>"u")return;const s=[`${e}=${encodeURIComponent(t)}`];_.isNumber(n)&&s.push(`expires=${new Date(n).toUTCString()}`),_.isString(r)&&s.push(`path=${r}`),_.isString(o)&&s.push(`domain=${o}`),i===!0&&s.push("secure"),_.isString(l)&&s.push(`SameSite=${l}`),document.cookie=s.join("; ")},read(e){if(typeof document>"u")return null;const t=document.cookie.split(";");for(let n=0;n0&&e.charCodeAt(n-1)===47;)n--;return e.slice(0,n)+"/"+t.replace(/^\/+/,"")}const P2=/^https?:(?!\/\/)/i;function O2(e){return e&&e.replace(/(^|&)([^=&]*=)?[^&]+/g,(t,n,r="")=>`${n}${r}${Ti}`)}function j2(e){const t=e.replace(/^(https?:\/{0,2})[^/?#]*@/i,`$1${Ti}@`),n=t.indexOf("#"),o=(n===-1?t:t.slice(0,n)).replace(/([?&][^=&#]*=)[^&#]*/g,`$1${Ti}`);return n===-1?o:`${o}#${O2(t.slice(n+1))}`}function cc(e,t){if(typeof e=="string"){const n=rp(e);if(P2.test(n))throw new I(`Invalid URL ${JSON.stringify(j2(n))}: missing "//" after protocol`,I.ERR_INVALID_URL,t)}}function op(e,t,n,r){cc(t,r);let o=!k2(t);return e&&(o||n===!1)?(cc(e,r),R2(e,t)):t}const fc=e=>e instanceof ze?{...e}:e,N2=e=>Object.getOwnPropertySymbols&&Object.getOwnPropertyDescriptor?Object.keys(e).concat(Object.getOwnPropertySymbols(e).filter(t=>Object.getOwnPropertyDescriptor(e,t).enumerable)):Object.keys(e);function Nn(e,t){e=e||{},t=t||{};const n=Object.create(null);Object.defineProperty(n,"hasOwnProperty",{__proto__:null,value:Object.prototype.hasOwnProperty,enumerable:!1,writable:!0,configurable:!0});function r(f,d,x,m){return _.isPlainObject(f)&&_.isPlainObject(d)?_.merge.call({caseless:m},f,d):_.isPlainObject(d)?_.merge({},d):_.isArray(d)?d.slice():d}function o(f,d,x,m){if(_.isUndefined(d)){if(!_.isUndefined(f))return r(void 0,f,x,m)}else return r(f,d,x,m)}function i(f,d){if(!_.isUndefined(d))return r(void 0,d)}function l(f,d){if(_.isUndefined(d)){if(!_.isUndefined(f))return r(void 0,f)}else return r(void 0,d)}function s(f){const d=_.hasOwnProp(t,"transitional")?t.transitional:void 0;if(!_.isUndefined(d))if(_.isPlainObject(d)){if(_.hasOwnProp(d,f))return d[f]}else return;const x=_.hasOwnProp(e,"transitional")?e.transitional:void 0;if(_.isPlainObject(x)&&_.hasOwnProp(x,f))return x[f]}function a(f,d,x){if(_.hasOwnProp(t,x))return r(f,d);if(_.hasOwnProp(e,x))return r(void 0,f)}const u={url:i,method:i,data:i,baseURL:l,transformRequest:l,transformResponse:l,paramsSerializer:l,timeout:l,timeoutErrorMessage:l,withCredentials:l,withXSRFToken:l,adapter:l,responseType:l,xsrfCookieName:l,xsrfHeaderName:l,onUploadProgress:l,onDownloadProgress:l,decompress:l,maxContentLength:l,maxBodyLength:l,beforeRedirect:l,transport:l,httpAgent:l,httpsAgent:l,cancelToken:l,socketPath:l,allowedSocketPaths:l,responseEncoding:l,validateStatus:a,headers:(f,d,x)=>o(fc(f),fc(d),x,!0)};return _.forEach(N2({...e,...t}),function(d){if(d==="__proto__"||d==="constructor"||d==="prototype")return;const x=_.hasOwnProp(u,d)?u[d]:o,m=_.hasOwnProp(e,d)?e[d]:void 0,y=_.hasOwnProp(t,d)?t[d]:void 0,g=x(m,y,d);_.isUndefined(g)&&x!==a||(n[d]=g)}),_.hasOwnProp(t,"validateStatus")&&_.isUndefined(t.validateStatus)&&s("validateStatusUndefinedResolves")===!1&&(_.hasOwnProp(e,"validateStatus")?n.validateStatus=r(void 0,e.validateStatus):delete n.validateStatus),n}const T2=["content-type","content-length"];function L2(e,t,n){if(n!=="content-only"){e.set(t);return}Object.entries(t||{}).forEach(([r,o])=>{T2.includes(r.toLowerCase())&&e.set(r,o)})}const z2=e=>encodeURIComponent(e).replace(/%([0-9A-F]{2})/gi,(t,n)=>String.fromCharCode(parseInt(n,16)));function ip(e){const t=Nn({},e),n=x=>_.hasOwnProp(t,x)?t[x]:void 0,r=n("data");let o=n("withXSRFToken");const i=n("xsrfHeaderName"),l=n("xsrfCookieName");let s=n("headers");const a=n("auth"),u=n("baseURL"),f=n("allowAbsoluteUrls"),d=n("url");if(t.headers=s=ze.from(s),t.url=Gx(op(u,d,f,t),n("params"),n("paramsSerializer")),a){const x=_.getSafeProp(a,"username")||"",m=_.getSafeProp(a,"password")||"";try{s.set("Authorization","Basic "+btoa(x+":"+(m?z2(m):"")))}catch(y){throw I.from(y,I.ERR_BAD_OPTION_VALUE,e)}}if(_.isFormData(r)){const x=_.getSafeProp(r,"getHeaders");_e.hasStandardBrowserEnv||_e.hasStandardBrowserWebWorkerEnv||_.isReactNative(r)?s.setContentType(void 0):_.isFunction(x)&&L2(s,x.call(r),n("formDataHeaderPolicy"))}if(_e.hasStandardBrowserEnv&&(_.isFunction(o)&&(o=o(t)),o===!0||o==null&&D2(t.url))){const m=i&&l&&F2.read(l);m&&s.set(i,m)}return t}const b2=typeof XMLHttpRequest<"u",I2=b2&&function(e){return new Promise(function(n,r){const o=ip(e);let i=o.data;const l=ze.from(o.headers).normalize();let{responseType:s,onUploadProgress:a,onDownloadProgress:u}=o,f,d,x,m,y,g;function E(){m&&m(),y&&y(),o.cancelToken&&o.cancelToken.unsubscribe(f),o.signal&&o.signal.removeEventListener("abort",f)}let p=new XMLHttpRequest;p.open(o.method.toUpperCase(),o.url,!0),p.timeout=o.timeout;function c(v){if(!p)return;if(p.status===0&&(T0(rp(o.url))||T0(_e.origin))!=="file"&&!(p.responseURL&&p.responseURL.startsWith("file:"))){r(new I("Request aborted",I.ECONNABORTED,e,p)),E(),p=null;return}try{v?g&&g(v):y&&y()}catch(D){setTimeout(()=>{throw D})}if(!p)return;const w=ze.from("getAllResponseHeaders"in p&&p.getAllResponseHeaders()),S={data:!s||s==="text"||s==="json"?p.responseText:p.response,status:p.status,statusText:p.statusText,headers:w,config:e,request:p};np(function(P){n(P),E()},function(P){r(P),E()},S),p=null}"onloadend"in p?p.onloadend=c:p.onreadystatechange=function(){!p||p.readyState!==4||p.status===0&&!(p.responseURL&&p.responseURL.startsWith("file:"))||setTimeout(c)},p.onabort=function(){p&&(r(new I("Request aborted",I.ECONNABORTED,e,p)),E(),p=null)},p.onerror=function(w){const B=w&&w.message?w.message:"Network Error",S=new I(B,I.ERR_NETWORK,e,p);S.event=w||null,r(S),E(),p=null},p.ontimeout=function(){let w=o.timeout?"timeout of "+o.timeout+"ms exceeded":"timeout exceeded";const B=o.transitional||ma;o.timeoutErrorMessage&&(w=o.timeoutErrorMessage),r(new I(w,B.clarifyTimeoutError?I.ETIMEDOUT:I.ECONNABORTED,e,p)),E(),p=null},i===void 0&&l.setContentType(null),"setRequestHeader"in p&&_.forEach(qx(l),function(w,B){p.setRequestHeader(B,w)}),_.isUndefined(o.withCredentials)||(p.withCredentials=!!o.withCredentials),s&&s!=="json"&&(p.responseType=o.responseType),u&&([x,y,g]=Li(u,!0),p.addEventListener("progress",x)),a&&p.upload&&([d,m]=Li(a),p.upload.addEventListener("progress",d),p.upload.addEventListener("loadend",m)),(o.cancelToken||o.signal)&&(f=v=>{p&&(r(!v||v.type?new Ro(null,e,p):v),p.abort(),E(),p=null)},o.cancelToken&&o.cancelToken.subscribe(f),o.signal&&(o.signal.aborted?f():o.signal.addEventListener("abort",f)));const h=T0(o.url);if(h&&!_e.protocols.includes(h)){r(new I("Unsupported protocol "+h+":",I.ERR_BAD_REQUEST,e)),E();return}p.send(i||null)})},U2=(e,t)=>{if(e=e?e.filter(Boolean):[],!t&&!e.length)return;const n=new AbortController;let r=!1;const o=function(a){if(!r){r=!0,l();const u=a instanceof Error?a:this.reason;n.abort(u instanceof I?u:new Ro(u instanceof Error?u.message:u))}};let i=t&&setTimeout(()=>{i=null,o(new I(`timeout of ${t}ms exceeded`,I.ETIMEDOUT))},t);const l=()=>{e&&(i&&clearTimeout(i),i=null,e.forEach(a=>{a.unsubscribe?a.unsubscribe(o):a.removeEventListener("abort",o)}),e=null)};e.forEach(a=>{if(!r){if(a.aborted){o.call(a);return}a.addEventListener("abort",o,{once:!0})}});const{signal:s}=n;return s.unsubscribe=()=>_.asap(l),s},H2=function*(e,t){let n=e.byteLength;if(n{const o=M2(e,t);let i=0,l,s=a=>{l||(l=!0,r&&r(a))};return new ReadableStream({async pull(a){try{const{done:u,value:f}=await o.next();if(u){s(),a.close();return}let d=f.byteLength;if(n){let x=i+=d;n(x)}a.enqueue(new Uint8Array(f))}catch(u){throw s(u),u}},cancel(a){return s(a),o.return()}},{highWaterMark:2})},xc=e=>e>=48&&e<=57||e>=65&&e<=70||e>=97&&e<=102,lp=(e,t,n)=>t+2e<=57?e-48:(e&223)-55,W2=e=>e>=65&&e<=90||e>=97&&e<=122||e>=48&&e<=57||e===43||e===47||e===45||e===95,q2=e=>e===9||e===10||e===12||e===13||e===32,V2=e=>{const t=Math.floor(e/4),n=e%4;return t*3+(n===2?1:n===3?2:0)},K2=e=>{const t=e.length;let n=0;return t>0&&e.charCodeAt(t-1)===61&&(n++,t>1&&e.charCodeAt(t-2)===61&&n++),Math.floor((t-n)*3/4)},Q2=e=>{const t=e.length;let n=0,r=0,o=!1;for(let i=0;i0){o=!0;continue}n++}}return o||r>2||r>0&&(n+r)%4!==0||n%4===1?K2(e):V2(n)},X2=(e,t)=>{if(!e||typeof e!="string"||!e.startsWith("data:"))return 0;const n=e.indexOf(",");if(n<0)return 0;const r=e.slice(5,n),o=e.slice(n+1);if(/;base64/i.test(r))return t(o);let l=0;for(let s=0,a=o.length;s=55296&&u<=56319&&s+1=56320&&f<=57343?(l+=4,s++):l+=3}else l+=3}return l};function G2(e){const t=typeof e=="string"?e.indexOf("#"):-1;return X2(t===-1?e:e.slice(0,t),Q2)}const ga="1.20.0",hc=64*1024,Y2={cache:"default",redirect:"follow",referrer:"about:client",referrerPolicy:"",mode:"cors",integrity:"",keepalive:!1,priority:"auto",window:null},{isFunction:Qo}=_,Z2=e=>encodeURIComponent(e).replace(/%([0-9A-F]{2})/gi,(t,n)=>String.fromCharCode(parseInt(n,16))),vc=e=>{if(!_.isString(e))return e;try{return decodeURIComponent(e)}catch{return e}},mc=(e,...t)=>{try{return!!e(...t)}catch{return!1}},J2=e=>{const t=e.indexOf("://");let n=e;return t!==-1&&(n=n.slice(t+3)),n.includes("@")||n.includes(":")},ey=e=>{const t=_.global!==void 0&&_.global!==null?_.global:globalThis,{ReadableStream:n,TextEncoder:r}=t;e=_.merge.call({skipUndefined:!0},{Request:t.Request,Response:t.Response},e);const{fetch:o,Request:i,Response:l}=e,s=o?Qo(o):typeof fetch=="function",a=Qo(i),u=Qo(l);if(!s)return!1;const f=s&&Qo(n),d=s&&(typeof r=="function"?(p=>c=>p.encode(c))(new r):async p=>new Uint8Array(await new i(p).arrayBuffer())),x=a&&f&&mc(()=>{let p=!1;const c=new i(_e.origin,{body:new n,method:"POST",get duplex(){return p=!0,"half"}}),h=c.headers.has("Content-Type");return c.body!=null&&c.body.cancel(),p&&!h}),m=u&&f&&mc(()=>_.isReadableStream(new l("").body)),y={stream:m&&(p=>p.body)};s&&["text","arrayBuffer","blob","formData","stream"].forEach(p=>{!y[p]&&(y[p]=(c,h)=>{let v=c&&c[p];if(v)return v.call(c);throw new I(`Response type '${p}' is not supported`,I.ERR_NOT_SUPPORT,h)})});const g=async p=>{if(p==null)return 0;if(_.isBlob(p))return p.size;if(_.isSpecCompliantForm(p))return(await new i(_e.origin,{method:"POST",body:p}).arrayBuffer()).byteLength;if(_.isArrayBufferView(p)||_.isArrayBuffer(p))return p.byteLength;if(_.isURLSearchParams(p)&&(p=p+""),_.isString(p))return(await d(p)).byteLength},E=async(p,c)=>{const h=_.toFiniteNumber(p.getContentLength());return h??g(c)};return async p=>{let{url:c,method:h,data:v,signal:w,cancelToken:B,timeout:S,onDownloadProgress:D,onUploadProgress:P,responseType:A,headers:F,withCredentials:j="same-origin",fetchOptions:N,maxContentLength:M,maxBodyLength:W,maxRedirects:Q}=ip(p);const Z=_.isNumber(M)&&M>-1,L=_.isNumber(W)&&W>-1,U=K=>_.hasOwnProp(p,K)?p[K]:void 0;let H=o||fetch;A=A?(A+"").toLowerCase():"text";let k=U2([w,B&&B.toAbortSignal()],S),R=null;const T=k&&k.unsubscribe&&(()=>{k.unsubscribe()});let O,ee=null;const G=()=>new I("Request body larger than maxBodyLength limit",I.ERR_BAD_REQUEST,p,R);try{let K;const q=U("auth");if(q){const V=_.getSafeProp(q,"username")||"",ge=_.getSafeProp(q,"password")||"";K={username:V,password:ge}}if(J2(c)){const V=new URL(c,_e.origin);if(!K&&(V.username||V.password)){const ge=vc(V.username),Ve=vc(V.password);K={username:ge,password:Ve}}(V.username||V.password)&&(V.username="",V.password="",c=V.href)}if(K&&(F.delete("authorization"),F.set("Authorization","Basic "+btoa(Z2((K.username||"")+":"+(K.password||""))))),Z&&typeof c=="string"&&c.startsWith("data:")&&G2(c)>M)throw new I("maxContentLength size of "+M+" exceeded",I.ERR_BAD_RESPONSE,p,R);if(L&&h!=="get"&&h!=="head"){const V=await g(v);if(typeof V=="number"&&isFinite(V)&&(O=V,V>W))throw G()}const wt=L&&(_.isReadableStream(v)||_.isStream(v)),Pt=(V,ge,Ve)=>dc(V,hc,we=>{if(L&&we>W)throw ee=G();ge&&ge(we)},Ve);if(x&&h!=="get"&&h!=="head"&&(P||wt)){if(O=O??await E(F,v),O!==0||wt){let V=new i(c,{method:"POST",body:v,duplex:"half"}),ge;if(_.isFormData(v)&&(ge=V.headers.get("content-type"))&&F.setContentType(ge),V.body){const[Ve,we]=P&&ac(O,Li(uc(P)))||[];v=Pt(V.body,Ve,we)}}}else if(wt&&!a&&f&&h!=="get"&&h!=="head")v=Pt(v);else if(wt&&a&&!x&&h!=="get"&&h!=="head")throw new I("Stream request bodies are not supported by the current fetch implementation",I.ERR_NOT_SUPPORT,p,R);_.isString(j)||(j=j?"include":"omit");const Sr=a&&"credentials"in i.prototype;if(_.isFormData(v)){const V=F.getContentType();V&&/^multipart\/form-data/i.test(V)&&!/boundary=/i.test(V)&&F.delete("content-type")}F.set("User-Agent","axios/"+ga,!1);const ke=N==null?N:Object.assign(Object.create(null),N);ke&&(delete ke.body,delete ke.headers,delete ke.method,delete ke.signal,delete ke.duplex,delete ke.credentials);const ve=Object.assign(Object.create(null),ke,{signal:k,method:h.toUpperCase(),headers:qx(F.normalize()),body:v,duplex:"half",credentials:Sr?j:void 0});a&&(_.forEach(Y2,(V,ge)=>{ve[ge]===void 0&&(ve[ge]=V)}),ve.signal===void 0&&(ve.signal=null),ve.body===void 0&&(ve.body=null)),Q===0&&(ve.redirect="manual",ke&&(ke.redirect="manual")),R=a&&new i(c,ve);let ce=await(a?H(R,ke):H(c,ve));const hn=ze.from(ce.headers);if(Z){const V=_.toFiniteNumber(hn.getContentLength());if(V!=null&&V>M)throw new I("maxContentLength size of "+M+" exceeded",I.ERR_BAD_RESPONSE,p,R)}const Ot=m&&(A==="stream"||A==="response");if(m&&ce.body&&(D||Z||Ot&&T)){const V={};["status","statusText","headers"].forEach(St=>{V[St]=ce[St]});const ge=_.toFiniteNumber(hn.getContentLength()),[Ve,we]=D&&ac(ge,Li(uc(D),!0))||[];let Ue=0;const Bt=St=>{if(Z&&(Ue=St,Ue>M))throw new I("maxContentLength size of "+M+" exceeded",I.ERR_BAD_RESPONSE,p,R);Ve&&Ve(St)};ce=new l(dc(ce.body,hc,Bt,()=>{we&&we(),T&&T()}),V)}A=A||"text";let qe=await y[_.findKey(y,A)||"text"](ce,p);if(Z&&!m&&!Ot){let V;if(qe!=null&&(typeof qe.byteLength=="number"?V=qe.byteLength:typeof qe.size=="number"?V=qe.size:typeof qe=="string"&&(V=typeof r=="function"?new r().encode(qe).byteLength:qe.length)),typeof V=="number"&&V>M)throw new I("maxContentLength size of "+M+" exceeded",I.ERR_BAD_RESPONSE,p,R)}return!Ot&&T&&T(),await new Promise((V,ge)=>{np(V,ge,{data:qe,headers:ze.from(ce.headers),status:ce.status,statusText:ce.statusText,config:p,request:R})})}catch(K){if(T&&T(),k&&k.aborted&&k.reason instanceof I){const q=k.reason;throw q.config=p,R&&(q.request=R),K!==q&&Object.defineProperty(q,"cause",{__proto__:null,value:K,writable:!0,enumerable:!1,configurable:!0}),q}if(ee)throw R&&!ee.request&&(ee.request=R),ee;if(K instanceof I)throw R&&!K.request&&(K.request=R),K;if(K&&K.name==="TypeError"&&/Load failed|fetch/i.test(K.message)){const q=new I("Network Error",I.ERR_NETWORK,p,R,K&&K.response);throw Object.defineProperty(q,"cause",{__proto__:null,value:K.cause||K,writable:!0,enumerable:!1,configurable:!0}),q}throw I.from(K,K&&K.code,p,R,K&&K.response)}}},ty=new Map,sp=e=>{let t=e&&e.env||{};const{fetch:n,Request:r,Response:o}=t,i=[r,o,n];let l=i.length,s=l,a,u,f=ty;for(;s--;)a=i[s],u=f.get(a),u===void 0&&f.set(a,u=s?new Map:ey(t)),f=u;return u};sp();const Ea={http:a2,xhr:I2,fetch:{get:sp}};_.forEach(Ea,(e,t)=>{if(e){try{Object.defineProperty(e,"name",{__proto__:null,value:t})}catch{}Object.defineProperty(e,"adapterName",{__proto__:null,value:t})}});const yc=e=>`- ${e}`,ny=e=>_.isFunction(e)||e===null||e===!1;function ry(e,t){e=_.isArray(e)?e:[e];const{length:n}=e;let r,o;const i={};for(let l=0;l`adapter ${a} `+(u===!1?"is not supported by the environment":"is not available in the build"));let s=n?l.length>1?`since : +`+l.map(yc).join(` +`):" "+yc(l[0]):"as no adapter specified";throw new I("There is no suitable adapter to dispatch the request "+s,I.ERR_NOT_SUPPORT)}return o}const ap={getAdapter:ry,adapters:Ea};function L0(e){if(e.cancelToken&&e.cancelToken.throwIfRequested(),e.signal&&e.signal.aborted)throw new Ro(null,e)}function z0(e){const t=_.toSafeFlatObject(e);return L0(t),t.headers=ze.from(_.getSafeProp(t,"headers")),t.data=N0.call(t,t.transformRequest),["post","put","patch"].indexOf(t.method)!==-1&&t.headers.setContentType("application/x-www-form-urlencoded",!1),ap.getAdapter(t.adapter||ko.adapter,t)(t).then(function(o){L0(t),t.response=o;try{o.data=N0.call(t,t.transformResponse,o)}finally{delete t.response}return o.headers=ze.from(o.headers),o},function(o){if(!tp(o)&&(L0(t),o&&o.response)){t.response=o.response;try{o.response.data=N0.call(t,t.transformResponse,o.response)}finally{delete t.response}o.response.headers=ze.from(o.response.headers)}return Promise.reject(o)})}const n0={};["object","boolean","number","function","string","symbol"].forEach((e,t)=>{n0[e]=function(r){return typeof r===e||"a"+(t<1?"n ":" ")+e}});const gc={};n0.transitional=function(t,n,r){function o(i,l){return"[Axios v"+ga+"] Transitional option '"+i+"'"+l+(r?". "+r:"")}return(i,l,s)=>{if(t===!1)throw new I(o(l," has been removed"+(n?" in "+n:"")),I.ERR_DEPRECATED);return n&&!gc[l]&&(gc[l]=!0,console.warn(o(l," has been deprecated since v"+n+" and will be removed in the near future"))),t?t(i,l,s):!0}};n0.spelling=function(t){return(n,r)=>(console.warn(`${r} is likely a misspelling of ${t}`),!0)};function oy(e,t,n){if(typeof e!="object"||e===null)throw new I("options must be an object",I.ERR_BAD_OPTION_VALUE);const r=Object.keys(e);let o=r.length;for(;o-- >0;){const i=r[o],l=Object.prototype.hasOwnProperty.call(t,i)?t[i]:void 0;if(l){const s=e[i],a=s===void 0||l(s,i,e);if(a!==!0)throw new I("option "+i+" must be "+a,I.ERR_BAD_OPTION_VALUE);continue}if(n!==!0)throw new I("Unknown option "+i,I.ERR_BAD_OPTION)}}const ui={assertOptions:oy,validators:n0},Te=ui.validators;let _n=class{constructor(t){this.defaults=t||{},this.interceptors={request:new lc,response:new lc}}async request(t,n){try{return await this._request(t,n)}catch(r){if(r instanceof Error)try{let o={};Error.captureStackTrace?Error.captureStackTrace(o):o=new Error;const i=o.stack;let l="";if(typeof i=="string"){const s=i.indexOf(` +`);l=s===-1?"":i.slice(s+1)}if(!r.stack)r.stack=l;else if(l){const s=l.indexOf(` +`),a=s===-1?-1:l.indexOf(` +`,s+1),u=a===-1?"":l.slice(a+1);String(r.stack).endsWith(u)||(r.stack+=` +`+l)}}catch{}throw r}}_request(t,n){typeof t=="string"?(n=n||{},n.url=t):n=t||{},n=Nn(this.defaults,n);const{transitional:r,paramsSerializer:o,headers:i}=n;r!==void 0&&ui.assertOptions(r,{silentJSONParsing:Te.transitional(Te.boolean),forcedJSONParsing:Te.transitional(Te.boolean),clarifyTimeoutError:Te.transitional(Te.boolean),legacyInterceptorReqResOrdering:Te.transitional(Te.boolean),advertiseZstdAcceptEncoding:Te.transitional(Te.boolean),validateStatusUndefinedResolves:Te.transitional(Te.boolean)},!1),o!=null&&(_.isFunction(o)?n.paramsSerializer={serialize:o}:ui.assertOptions(o,{encode:Te.function,serialize:Te.function},!0)),n.allowAbsoluteUrls!==void 0||(this.defaults.allowAbsoluteUrls!==void 0?n.allowAbsoluteUrls=this.defaults.allowAbsoluteUrls:n.allowAbsoluteUrls=!0),ui.assertOptions(n,{baseUrl:Te.spelling("baseURL"),withXsrfToken:Te.spelling("withXSRFToken")},!0),n.method=(_.getSafeProp(n,"method")||_.getSafeProp(this.defaults,"method")||"get").toLowerCase();let l=i&&_.merge(i.common,i[n.method]);i&&_.forEach(ep.concat("common"),y=>{delete i[y]}),n.headers=ze.concat(l,i);const s=[];let a=!0;this.interceptors.request.forEach(function(g){if(typeof g.runWhen=="function"&&g.runWhen(n)===!1)return;a=a&&g.synchronous;const E=n.transitional||ma;E&&E.legacyInterceptorReqResOrdering?s.unshift(g.fulfilled,g.rejected):s.push(g.fulfilled,g.rejected)});const u=[];this.interceptors.response.forEach(function(g){u.push(g.fulfilled,g.rejected)});let f,d=0,x;if(!a){const y=[z0.bind(this),void 0];for(y.unshift(...s),y.push(...u),x=y.length,f=Promise.resolve(n);dz0.call(this,m)))}catch(p){f=Promise.reject(p)}break}}if(!f)try{f=z0.call(this,m)}catch(y){f=Promise.reject(y)}for(d=0,x=u.length;d{if(!r._listeners)return;let i=r._listeners.length;for(;i-- >0;)r._listeners[i](o);r._listeners=null}),this.promise.then=o=>{let i;const l=new Promise(s=>{r.subscribe(s),i=s}).then(o);return l.cancel=function(){r.unsubscribe(i)},l},t(function(i,l,s){r.reason||(r.reason=new Ro(i,l,s),n(r.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(t){if(this.reason){t(this.reason);return}this._listeners?this._listeners.push(t):this._listeners=[t]}unsubscribe(t){if(!this._listeners)return;const n=this._listeners.indexOf(t);n!==-1&&this._listeners.splice(n,1)}toAbortSignal(){const t=new AbortController,n=r=>{t.abort(r)};return this.subscribe(n),t.signal.unsubscribe=()=>this.unsubscribe(n),t.signal}static source(){let t;return{token:new up(function(o){t=o}),cancel:t}}};function ly(e){return function(n){return e.apply(null,n)}}function sy(e){return _.isObject(e)&&e.isAxiosError===!0}const ci={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,ContentTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,UnprocessableContent:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511,WebServerReturnsAnUnknownError:520,WebServerIsDown:521,ConnectionTimedOut:522,OriginIsUnreachable:523,TimeoutOccurred:524,SslHandshakeFailed:525,InvalidSslCertificate:526};Object.entries(ci).forEach(([e,t])=>{ci[t]===void 0&&(ci[t]=e)});function cp(e){const t=new _n(e),n=Nx(_n.prototype.request,t);return _.extend(n,_n.prototype,t,{allOwnKeys:!0}),_.extend(n,t,null,{allOwnKeys:!0}),n.create=function(o){return cp(Nn(e,o))},n}const ye=cp(ko);ye.Axios=_n;ye.CanceledError=Ro;ye.CancelToken=iy;ye.isCancel=tp;ye.VERSION=ga;ye.toFormData=t0;ye.AxiosError=I;ye.Cancel=ye.CanceledError;ye.all=function(t){return Promise.all(t)};ye.spread=ly;ye.isAxiosError=sy;ye.mergeConfig=Nn;ye.AxiosHeaders=ze;ye.formToJSON=e=>Jx(_.isHTMLForm(e)?new FormData(e):e);ye.getAdapter=ap.getAdapter;ye.HttpStatusCode=ci;ye.default=ye;const{Axios:Dg,AxiosError:Fg,CanceledError:kg,isCancel:Rg,CancelToken:Pg,VERSION:Og,all:jg,Cancel:Ng,isAxiosError:Tg,spread:Lg,toFormData:zg,AxiosHeaders:bg,HttpStatusCode:Ig,formToJSON:Ug,getAdapter:Hg,mergeConfig:Mg,create:$g}=ye,Ca="ssw_token";function fp(){return localStorage.getItem(Ca)}function ay(e){const t=e.startsWith("bearer ")?e:`bearer ${e}`;localStorage.setItem(Ca,t)}function ms(){localStorage.removeItem(Ca)}const oe=ye.create({baseURL:"/api",timeout:3e4});oe.interceptors.request.use(e=>{const t=fp();return e.headers.set("App-Code","sswflow"),e.headers.set("Jnpf-Origin","pc"),t&&e.headers.set("Authorization",t),e});function Ec(){location.pathname!=="/login"&&location.replace(`/login?next=${encodeURIComponent(location.pathname+location.search)}`)}oe.interceptors.response.use(e=>{const t=e.data||{};return t.code===600||t.code===601||t.code===602?(ms(),Ec(),Promise.reject(new Error("NOT_LOGIN"))):t.code!==void 0&&t.code!==200?Promise.reject(new Error(t.msg||"操作失败")):t.data!==void 0?t.data:t},e=>{var r,o;const t=(r=e.response)==null?void 0:r.status,n=((o=e.response)==null?void 0:o.data)||{};return t===401||n.code===600||n.code===601||n.code===602?(ms(),Ec(),Promise.reject(new Error("NOT_LOGIN"))):Promise.reject(new Error(n.msg||e.message||"请求失败"))});async function uy(e,t){const n=new URLSearchParams;return n.set("account",e),n.set("password",t),n.set("grant_type","password"),await oe.post("/oauth/Login",n.toString(),{headers:{"Content-Type":"application/x-www-form-urlencoded"}})}async function cy(){return await oe.get("/oauth/CurrentUser")}var dp={exports:{}};function fy(e){throw new Error('Could not dynamically require "'+e+'". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.')}var b0={exports:{}};const dy={},xy=Object.freeze(Object.defineProperty({__proto__:null,default:dy},Symbol.toStringTag,{value:"Module"})),py=Pp(xy);var Cc;function J(){return Cc||(Cc=1,function(e,t){(function(n,r){e.exports=r()})(X,function(){var n=n||function(r,o){var i;if(typeof window<"u"&&window.crypto&&(i=window.crypto),typeof self<"u"&&self.crypto&&(i=self.crypto),typeof globalThis<"u"&&globalThis.crypto&&(i=globalThis.crypto),!i&&typeof window<"u"&&window.msCrypto&&(i=window.msCrypto),!i&&typeof X<"u"&&X.crypto&&(i=X.crypto),!i&&typeof fy=="function")try{i=py}catch{}var l=function(){if(i){if(typeof i.getRandomValues=="function")try{return i.getRandomValues(new Uint32Array(1))[0]}catch{}if(typeof i.randomBytes=="function")try{return i.randomBytes(4).readInt32LE()}catch{}}throw new Error("Native crypto module could not be used to get secure random number.")},s=Object.create||function(){function c(){}return function(h){var v;return c.prototype=h,v=new c,c.prototype=null,v}}(),a={},u=a.lib={},f=u.Base=function(){return{extend:function(c){var h=s(this);return c&&h.mixIn(c),(!h.hasOwnProperty("init")||this.init===h.init)&&(h.init=function(){h.$super.init.apply(this,arguments)}),h.init.prototype=h,h.$super=this,h},create:function(){var c=this.extend();return c.init.apply(c,arguments),c},init:function(){},mixIn:function(c){for(var h in c)c.hasOwnProperty(h)&&(this[h]=c[h]);c.hasOwnProperty("toString")&&(this.toString=c.toString)},clone:function(){return this.init.prototype.extend(this)}}}(),d=u.WordArray=f.extend({init:function(c,h){c=this.words=c||[],h!=o?this.sigBytes=h:this.sigBytes=c.length*4},toString:function(c){return(c||m).stringify(this)},concat:function(c){var h=this.words,v=c.words,w=this.sigBytes,B=c.sigBytes;if(this.clamp(),w%4)for(var S=0;S>>2]>>>24-S%4*8&255;h[w+S>>>2]|=D<<24-(w+S)%4*8}else for(var P=0;P>>2]=v[P>>>2];return this.sigBytes+=B,this},clamp:function(){var c=this.words,h=this.sigBytes;c[h>>>2]&=4294967295<<32-h%4*8,c.length=r.ceil(h/4)},clone:function(){var c=f.clone.call(this);return c.words=this.words.slice(0),c},random:function(c){for(var h=[],v=0;v>>2]>>>24-B%4*8&255;w.push((S>>>4).toString(16)),w.push((S&15).toString(16))}return w.join("")},parse:function(c){for(var h=c.length,v=[],w=0;w>>3]|=parseInt(c.substr(w,2),16)<<24-w%8*4;return new d.init(v,h/2)}},y=x.Latin1={stringify:function(c){for(var h=c.words,v=c.sigBytes,w=[],B=0;B>>2]>>>24-B%4*8&255;w.push(String.fromCharCode(S))}return w.join("")},parse:function(c){for(var h=c.length,v=[],w=0;w>>2]|=(c.charCodeAt(w)&255)<<24-w%4*8;return new d.init(v,h)}},g=x.Utf8={stringify:function(c){try{return decodeURIComponent(escape(y.stringify(c)))}catch{throw new Error("Malformed UTF-8 data")}},parse:function(c){return y.parse(unescape(encodeURIComponent(c)))}},E=u.BufferedBlockAlgorithm=f.extend({reset:function(){this._data=new d.init,this._nDataBytes=0},_append:function(c){typeof c=="string"&&(c=g.parse(c)),this._data.concat(c),this._nDataBytes+=c.sigBytes},_process:function(c){var h,v=this._data,w=v.words,B=v.sigBytes,S=this.blockSize,D=S*4,P=B/D;c?P=r.ceil(P):P=r.max((P|0)-this._minBufferSize,0);var A=P*S,F=r.min(A*4,B);if(A){for(var j=0;j>>2]|=a[d]<<24-d%4*8;l.call(this,f,u)}else l.apply(this,arguments)};s.prototype=i}}(),n.lib.WordArray})}(U0)),U0.exports}var H0={exports:{}},Sc;function vy(){return Sc||(Sc=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){return function(){var r=n,o=r.lib,i=o.WordArray,l=r.enc;l.Utf16=l.Utf16BE={stringify:function(a){for(var u=a.words,f=a.sigBytes,d=[],x=0;x>>2]>>>16-x%4*8&65535;d.push(String.fromCharCode(m))}return d.join("")},parse:function(a){for(var u=a.length,f=[],d=0;d>>1]|=a.charCodeAt(d)<<16-d%2*16;return i.create(f,u*2)}},l.Utf16LE={stringify:function(a){for(var u=a.words,f=a.sigBytes,d=[],x=0;x>>2]>>>16-x%4*8&65535);d.push(String.fromCharCode(m))}return d.join("")},parse:function(a){for(var u=a.length,f=[],d=0;d>>1]|=s(a.charCodeAt(d)<<16-d%2*16);return i.create(f,u*2)}};function s(a){return a<<8&4278255360|a>>>8&16711935}}(),n.enc.Utf16})}(H0)),H0.exports}var M0={exports:{}},Ac;function bn(){return Ac||(Ac=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){return function(){var r=n,o=r.lib,i=o.WordArray,l=r.enc;l.Base64={stringify:function(a){var u=a.words,f=a.sigBytes,d=this._map;a.clamp();for(var x=[],m=0;m>>2]>>>24-m%4*8&255,g=u[m+1>>>2]>>>24-(m+1)%4*8&255,E=u[m+2>>>2]>>>24-(m+2)%4*8&255,p=y<<16|g<<8|E,c=0;c<4&&m+c*.75>>6*(3-c)&63));var h=d.charAt(64);if(h)for(;x.length%4;)x.push(h);return x.join("")},parse:function(a){var u=a.length,f=this._map,d=this._reverseMap;if(!d){d=this._reverseMap=[];for(var x=0;x>>6-m%4*2,E=y|g;d[x>>>2]|=E<<24-x%4*8,x++}return i.create(d,x)}}(),n.enc.Base64})}(M0)),M0.exports}var $0={exports:{}},_c;function my(){return _c||(_c=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){return function(){var r=n,o=r.lib,i=o.WordArray,l=r.enc;l.Base64url={stringify:function(a,u){u===void 0&&(u=!0);var f=a.words,d=a.sigBytes,x=u?this._safe_map:this._map;a.clamp();for(var m=[],y=0;y>>2]>>>24-y%4*8&255,E=f[y+1>>>2]>>>24-(y+1)%4*8&255,p=f[y+2>>>2]>>>24-(y+2)%4*8&255,c=g<<16|E<<8|p,h=0;h<4&&y+h*.75>>6*(3-h)&63));var v=x.charAt(64);if(v)for(;m.length%4;)m.push(v);return m.join("")},parse:function(a,u){u===void 0&&(u=!0);var f=a.length,d=u?this._safe_map:this._map,x=this._reverseMap;if(!x){x=this._reverseMap=[];for(var m=0;m>>6-m%4*2,E=y|g;d[x>>>2]|=E<<24-x%4*8,x++}return i.create(d,x)}}(),n.enc.Base64url})}($0)),$0.exports}var W0={exports:{}},Dc;function In(){return Dc||(Dc=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){return function(r){var o=n,i=o.lib,l=i.WordArray,s=i.Hasher,a=o.algo,u=[];(function(){for(var g=0;g<64;g++)u[g]=r.abs(r.sin(g+1))*4294967296|0})();var f=a.MD5=s.extend({_doReset:function(){this._hash=new l.init([1732584193,4023233417,2562383102,271733878])},_doProcessBlock:function(g,E){for(var p=0;p<16;p++){var c=E+p,h=g[c];g[c]=(h<<8|h>>>24)&16711935|(h<<24|h>>>8)&4278255360}var v=this._hash.words,w=g[E+0],B=g[E+1],S=g[E+2],D=g[E+3],P=g[E+4],A=g[E+5],F=g[E+6],j=g[E+7],N=g[E+8],M=g[E+9],W=g[E+10],Q=g[E+11],Z=g[E+12],L=g[E+13],U=g[E+14],H=g[E+15],k=v[0],R=v[1],T=v[2],O=v[3];k=d(k,R,T,O,w,7,u[0]),O=d(O,k,R,T,B,12,u[1]),T=d(T,O,k,R,S,17,u[2]),R=d(R,T,O,k,D,22,u[3]),k=d(k,R,T,O,P,7,u[4]),O=d(O,k,R,T,A,12,u[5]),T=d(T,O,k,R,F,17,u[6]),R=d(R,T,O,k,j,22,u[7]),k=d(k,R,T,O,N,7,u[8]),O=d(O,k,R,T,M,12,u[9]),T=d(T,O,k,R,W,17,u[10]),R=d(R,T,O,k,Q,22,u[11]),k=d(k,R,T,O,Z,7,u[12]),O=d(O,k,R,T,L,12,u[13]),T=d(T,O,k,R,U,17,u[14]),R=d(R,T,O,k,H,22,u[15]),k=x(k,R,T,O,B,5,u[16]),O=x(O,k,R,T,F,9,u[17]),T=x(T,O,k,R,Q,14,u[18]),R=x(R,T,O,k,w,20,u[19]),k=x(k,R,T,O,A,5,u[20]),O=x(O,k,R,T,W,9,u[21]),T=x(T,O,k,R,H,14,u[22]),R=x(R,T,O,k,P,20,u[23]),k=x(k,R,T,O,M,5,u[24]),O=x(O,k,R,T,U,9,u[25]),T=x(T,O,k,R,D,14,u[26]),R=x(R,T,O,k,N,20,u[27]),k=x(k,R,T,O,L,5,u[28]),O=x(O,k,R,T,S,9,u[29]),T=x(T,O,k,R,j,14,u[30]),R=x(R,T,O,k,Z,20,u[31]),k=m(k,R,T,O,A,4,u[32]),O=m(O,k,R,T,N,11,u[33]),T=m(T,O,k,R,Q,16,u[34]),R=m(R,T,O,k,U,23,u[35]),k=m(k,R,T,O,B,4,u[36]),O=m(O,k,R,T,P,11,u[37]),T=m(T,O,k,R,j,16,u[38]),R=m(R,T,O,k,W,23,u[39]),k=m(k,R,T,O,L,4,u[40]),O=m(O,k,R,T,w,11,u[41]),T=m(T,O,k,R,D,16,u[42]),R=m(R,T,O,k,F,23,u[43]),k=m(k,R,T,O,M,4,u[44]),O=m(O,k,R,T,Z,11,u[45]),T=m(T,O,k,R,H,16,u[46]),R=m(R,T,O,k,S,23,u[47]),k=y(k,R,T,O,w,6,u[48]),O=y(O,k,R,T,j,10,u[49]),T=y(T,O,k,R,U,15,u[50]),R=y(R,T,O,k,A,21,u[51]),k=y(k,R,T,O,Z,6,u[52]),O=y(O,k,R,T,D,10,u[53]),T=y(T,O,k,R,W,15,u[54]),R=y(R,T,O,k,B,21,u[55]),k=y(k,R,T,O,N,6,u[56]),O=y(O,k,R,T,H,10,u[57]),T=y(T,O,k,R,F,15,u[58]),R=y(R,T,O,k,L,21,u[59]),k=y(k,R,T,O,P,6,u[60]),O=y(O,k,R,T,Q,10,u[61]),T=y(T,O,k,R,S,15,u[62]),R=y(R,T,O,k,M,21,u[63]),v[0]=v[0]+k|0,v[1]=v[1]+R|0,v[2]=v[2]+T|0,v[3]=v[3]+O|0},_doFinalize:function(){var g=this._data,E=g.words,p=this._nDataBytes*8,c=g.sigBytes*8;E[c>>>5]|=128<<24-c%32;var h=r.floor(p/4294967296),v=p;E[(c+64>>>9<<4)+15]=(h<<8|h>>>24)&16711935|(h<<24|h>>>8)&4278255360,E[(c+64>>>9<<4)+14]=(v<<8|v>>>24)&16711935|(v<<24|v>>>8)&4278255360,g.sigBytes=(E.length+1)*4,this._process();for(var w=this._hash,B=w.words,S=0;S<4;S++){var D=B[S];B[S]=(D<<8|D>>>24)&16711935|(D<<24|D>>>8)&4278255360}return w},clone:function(){var g=s.clone.call(this);return g._hash=this._hash.clone(),g}});function d(g,E,p,c,h,v,w){var B=g+(E&p|~E&c)+h+w;return(B<>>32-v)+E}function x(g,E,p,c,h,v,w){var B=g+(E&c|p&~c)+h+w;return(B<>>32-v)+E}function m(g,E,p,c,h,v,w){var B=g+(E^p^c)+h+w;return(B<>>32-v)+E}function y(g,E,p,c,h,v,w){var B=g+(p^(E|~c))+h+w;return(B<>>32-v)+E}o.MD5=s._createHelper(f),o.HmacMD5=s._createHmacHelper(f)}(Math),n.MD5})}(W0)),W0.exports}var q0={exports:{}},Fc;function xp(){return Fc||(Fc=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){return function(){var r=n,o=r.lib,i=o.WordArray,l=o.Hasher,s=r.algo,a=[],u=s.SHA1=l.extend({_doReset:function(){this._hash=new i.init([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(f,d){for(var x=this._hash.words,m=x[0],y=x[1],g=x[2],E=x[3],p=x[4],c=0;c<80;c++){if(c<16)a[c]=f[d+c]|0;else{var h=a[c-3]^a[c-8]^a[c-14]^a[c-16];a[c]=h<<1|h>>>31}var v=(m<<5|m>>>27)+p+a[c];c<20?v+=(y&g|~y&E)+1518500249:c<40?v+=(y^g^E)+1859775393:c<60?v+=(y&g|y&E|g&E)-1894007588:v+=(y^g^E)-899497514,p=E,E=g,g=y<<30|y>>>2,y=m,m=v}x[0]=x[0]+m|0,x[1]=x[1]+y|0,x[2]=x[2]+g|0,x[3]=x[3]+E|0,x[4]=x[4]+p|0},_doFinalize:function(){var f=this._data,d=f.words,x=this._nDataBytes*8,m=f.sigBytes*8;return d[m>>>5]|=128<<24-m%32,d[(m+64>>>9<<4)+14]=Math.floor(x/4294967296),d[(m+64>>>9<<4)+15]=x,f.sigBytes=d.length*4,this._process(),this._hash},clone:function(){var f=l.clone.call(this);return f._hash=this._hash.clone(),f}});r.SHA1=l._createHelper(u),r.HmacSHA1=l._createHmacHelper(u)}(),n.SHA1})}(q0)),q0.exports}var V0={exports:{}},kc;function wa(){return kc||(kc=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){return function(r){var o=n,i=o.lib,l=i.WordArray,s=i.Hasher,a=o.algo,u=[],f=[];(function(){function m(p){for(var c=r.sqrt(p),h=2;h<=c;h++)if(!(p%h))return!1;return!0}function y(p){return(p-(p|0))*4294967296|0}for(var g=2,E=0;E<64;)m(g)&&(E<8&&(u[E]=y(r.pow(g,1/2))),f[E]=y(r.pow(g,1/3)),E++),g++})();var d=[],x=a.SHA256=s.extend({_doReset:function(){this._hash=new l.init(u.slice(0))},_doProcessBlock:function(m,y){for(var g=this._hash.words,E=g[0],p=g[1],c=g[2],h=g[3],v=g[4],w=g[5],B=g[6],S=g[7],D=0;D<64;D++){if(D<16)d[D]=m[y+D]|0;else{var P=d[D-15],A=(P<<25|P>>>7)^(P<<14|P>>>18)^P>>>3,F=d[D-2],j=(F<<15|F>>>17)^(F<<13|F>>>19)^F>>>10;d[D]=A+d[D-7]+j+d[D-16]}var N=v&w^~v&B,M=E&p^E&c^p&c,W=(E<<30|E>>>2)^(E<<19|E>>>13)^(E<<10|E>>>22),Q=(v<<26|v>>>6)^(v<<21|v>>>11)^(v<<7|v>>>25),Z=S+Q+N+f[D]+d[D],L=W+M;S=B,B=w,w=v,v=h+Z|0,h=c,c=p,p=E,E=Z+L|0}g[0]=g[0]+E|0,g[1]=g[1]+p|0,g[2]=g[2]+c|0,g[3]=g[3]+h|0,g[4]=g[4]+v|0,g[5]=g[5]+w|0,g[6]=g[6]+B|0,g[7]=g[7]+S|0},_doFinalize:function(){var m=this._data,y=m.words,g=this._nDataBytes*8,E=m.sigBytes*8;return y[E>>>5]|=128<<24-E%32,y[(E+64>>>9<<4)+14]=r.floor(g/4294967296),y[(E+64>>>9<<4)+15]=g,m.sigBytes=y.length*4,this._process(),this._hash},clone:function(){var m=s.clone.call(this);return m._hash=this._hash.clone(),m}});o.SHA256=s._createHelper(x),o.HmacSHA256=s._createHmacHelper(x)}(Math),n.SHA256})}(V0)),V0.exports}var K0={exports:{}},Rc;function yy(){return Rc||(Rc=1,function(e,t){(function(n,r,o){e.exports=r(J(),wa())})(X,function(n){return function(){var r=n,o=r.lib,i=o.WordArray,l=r.algo,s=l.SHA256,a=l.SHA224=s.extend({_doReset:function(){this._hash=new i.init([3238371032,914150663,812702999,4144912697,4290775857,1750603025,1694076839,3204075428])},_doFinalize:function(){var u=s._doFinalize.call(this);return u.sigBytes-=4,u}});r.SHA224=s._createHelper(a),r.HmacSHA224=s._createHmacHelper(a)}(),n.SHA224})}(K0)),K0.exports}var Q0={exports:{}},Pc;function pp(){return Pc||(Pc=1,function(e,t){(function(n,r,o){e.exports=r(J(),r0())})(X,function(n){return function(){var r=n,o=r.lib,i=o.Hasher,l=r.x64,s=l.Word,a=l.WordArray,u=r.algo;function f(){return s.create.apply(s,arguments)}var d=[f(1116352408,3609767458),f(1899447441,602891725),f(3049323471,3964484399),f(3921009573,2173295548),f(961987163,4081628472),f(1508970993,3053834265),f(2453635748,2937671579),f(2870763221,3664609560),f(3624381080,2734883394),f(310598401,1164996542),f(607225278,1323610764),f(1426881987,3590304994),f(1925078388,4068182383),f(2162078206,991336113),f(2614888103,633803317),f(3248222580,3479774868),f(3835390401,2666613458),f(4022224774,944711139),f(264347078,2341262773),f(604807628,2007800933),f(770255983,1495990901),f(1249150122,1856431235),f(1555081692,3175218132),f(1996064986,2198950837),f(2554220882,3999719339),f(2821834349,766784016),f(2952996808,2566594879),f(3210313671,3203337956),f(3336571891,1034457026),f(3584528711,2466948901),f(113926993,3758326383),f(338241895,168717936),f(666307205,1188179964),f(773529912,1546045734),f(1294757372,1522805485),f(1396182291,2643833823),f(1695183700,2343527390),f(1986661051,1014477480),f(2177026350,1206759142),f(2456956037,344077627),f(2730485921,1290863460),f(2820302411,3158454273),f(3259730800,3505952657),f(3345764771,106217008),f(3516065817,3606008344),f(3600352804,1432725776),f(4094571909,1467031594),f(275423344,851169720),f(430227734,3100823752),f(506948616,1363258195),f(659060556,3750685593),f(883997877,3785050280),f(958139571,3318307427),f(1322822218,3812723403),f(1537002063,2003034995),f(1747873779,3602036899),f(1955562222,1575990012),f(2024104815,1125592928),f(2227730452,2716904306),f(2361852424,442776044),f(2428436474,593698344),f(2756734187,3733110249),f(3204031479,2999351573),f(3329325298,3815920427),f(3391569614,3928383900),f(3515267271,566280711),f(3940187606,3454069534),f(4118630271,4000239992),f(116418474,1914138554),f(174292421,2731055270),f(289380356,3203993006),f(460393269,320620315),f(685471733,587496836),f(852142971,1086792851),f(1017036298,365543100),f(1126000580,2618297676),f(1288033470,3409855158),f(1501505948,4234509866),f(1607167915,987167468),f(1816402316,1246189591)],x=[];(function(){for(var y=0;y<80;y++)x[y]=f()})();var m=u.SHA512=i.extend({_doReset:function(){this._hash=new a.init([new s.init(1779033703,4089235720),new s.init(3144134277,2227873595),new s.init(1013904242,4271175723),new s.init(2773480762,1595750129),new s.init(1359893119,2917565137),new s.init(2600822924,725511199),new s.init(528734635,4215389547),new s.init(1541459225,327033209)])},_doProcessBlock:function(y,g){for(var E=this._hash.words,p=E[0],c=E[1],h=E[2],v=E[3],w=E[4],B=E[5],S=E[6],D=E[7],P=p.high,A=p.low,F=c.high,j=c.low,N=h.high,M=h.low,W=v.high,Q=v.low,Z=w.high,L=w.low,U=B.high,H=B.low,k=S.high,R=S.low,T=D.high,O=D.low,ee=P,G=A,K=F,q=j,wt=N,Pt=M,Sr=W,ke=Q,ve=Z,ce=L,hn=U,Ot=H,qe=k,V=R,ge=T,Ve=O,we=0;we<80;we++){var Ue,Bt,St=x[we];if(we<16)Bt=St.high=y[g+we*2]|0,Ue=St.low=y[g+we*2+1]|0;else{var Sa=x[we-15],Hn=Sa.high,Ar=Sa.low,mp=(Hn>>>1|Ar<<31)^(Hn>>>8|Ar<<24)^Hn>>>7,Aa=(Ar>>>1|Hn<<31)^(Ar>>>8|Hn<<24)^(Ar>>>7|Hn<<25),_a=x[we-2],Mn=_a.high,_r=_a.low,yp=(Mn>>>19|_r<<13)^(Mn<<3|_r>>>29)^Mn>>>6,Da=(_r>>>19|Mn<<13)^(_r<<3|Mn>>>29)^(_r>>>6|Mn<<26),Fa=x[we-7],gp=Fa.high,Ep=Fa.low,ka=x[we-16],Cp=ka.high,Ra=ka.low;Ue=Aa+Ep,Bt=mp+gp+(Ue>>>0>>0?1:0),Ue=Ue+Da,Bt=Bt+yp+(Ue>>>0>>0?1:0),Ue=Ue+Ra,Bt=Bt+Cp+(Ue>>>0>>0?1:0),St.high=Bt,St.low=Ue}var wp=ve&hn^~ve&qe,Pa=ce&Ot^~ce&V,Bp=ee&K^ee&wt^K&wt,Sp=G&q^G&Pt^q&Pt,Ap=(ee>>>28|G<<4)^(ee<<30|G>>>2)^(ee<<25|G>>>7),Oa=(G>>>28|ee<<4)^(G<<30|ee>>>2)^(G<<25|ee>>>7),_p=(ve>>>14|ce<<18)^(ve>>>18|ce<<14)^(ve<<23|ce>>>9),Dp=(ce>>>14|ve<<18)^(ce>>>18|ve<<14)^(ce<<23|ve>>>9),ja=d[we],Fp=ja.high,Na=ja.low,Je=Ve+Dp,$t=ge+_p+(Je>>>0>>0?1:0),Je=Je+Pa,$t=$t+wp+(Je>>>0>>0?1:0),Je=Je+Na,$t=$t+Fp+(Je>>>0>>0?1:0),Je=Je+Ue,$t=$t+Bt+(Je>>>0>>0?1:0),Ta=Oa+Sp,kp=Ap+Bp+(Ta>>>0>>0?1:0);ge=qe,Ve=V,qe=hn,V=Ot,hn=ve,Ot=ce,ce=ke+Je|0,ve=Sr+$t+(ce>>>0>>0?1:0)|0,Sr=wt,ke=Pt,wt=K,Pt=q,K=ee,q=G,G=Je+Ta|0,ee=$t+kp+(G>>>0>>0?1:0)|0}A=p.low=A+G,p.high=P+ee+(A>>>0>>0?1:0),j=c.low=j+q,c.high=F+K+(j>>>0>>0?1:0),M=h.low=M+Pt,h.high=N+wt+(M>>>0>>0?1:0),Q=v.low=Q+ke,v.high=W+Sr+(Q>>>0>>0?1:0),L=w.low=L+ce,w.high=Z+ve+(L>>>0>>0?1:0),H=B.low=H+Ot,B.high=U+hn+(H>>>0>>0?1:0),R=S.low=R+V,S.high=k+qe+(R>>>0>>0?1:0),O=D.low=O+Ve,D.high=T+ge+(O>>>0>>0?1:0)},_doFinalize:function(){var y=this._data,g=y.words,E=this._nDataBytes*8,p=y.sigBytes*8;g[p>>>5]|=128<<24-p%32,g[(p+128>>>10<<5)+30]=Math.floor(E/4294967296),g[(p+128>>>10<<5)+31]=E,y.sigBytes=g.length*4,this._process();var c=this._hash.toX32();return c},clone:function(){var y=i.clone.call(this);return y._hash=this._hash.clone(),y},blockSize:1024/32});r.SHA512=i._createHelper(m),r.HmacSHA512=i._createHmacHelper(m)}(),n.SHA512})}(Q0)),Q0.exports}var X0={exports:{}},Oc;function gy(){return Oc||(Oc=1,function(e,t){(function(n,r,o){e.exports=r(J(),r0(),pp())})(X,function(n){return function(){var r=n,o=r.x64,i=o.Word,l=o.WordArray,s=r.algo,a=s.SHA512,u=s.SHA384=a.extend({_doReset:function(){this._hash=new l.init([new i.init(3418070365,3238371032),new i.init(1654270250,914150663),new i.init(2438529370,812702999),new i.init(355462360,4144912697),new i.init(1731405415,4290775857),new i.init(2394180231,1750603025),new i.init(3675008525,1694076839),new i.init(1203062813,3204075428)])},_doFinalize:function(){var f=a._doFinalize.call(this);return f.sigBytes-=16,f}});r.SHA384=a._createHelper(u),r.HmacSHA384=a._createHmacHelper(u)}(),n.SHA384})}(X0)),X0.exports}var G0={exports:{}},jc;function Ey(){return jc||(jc=1,function(e,t){(function(n,r,o){e.exports=r(J(),r0())})(X,function(n){return function(r){var o=n,i=o.lib,l=i.WordArray,s=i.Hasher,a=o.x64,u=a.Word,f=o.algo,d=[],x=[],m=[];(function(){for(var E=1,p=0,c=0;c<24;c++){d[E+5*p]=(c+1)*(c+2)/2%64;var h=p%5,v=(2*E+3*p)%5;E=h,p=v}for(var E=0;E<5;E++)for(var p=0;p<5;p++)x[E+5*p]=p+(2*E+3*p)%5*5;for(var w=1,B=0;B<24;B++){for(var S=0,D=0,P=0;P<7;P++){if(w&1){var A=(1<>>24)&16711935|(w<<24|w>>>8)&4278255360,B=(B<<8|B>>>24)&16711935|(B<<24|B>>>8)&4278255360;var S=c[v];S.high^=B,S.low^=w}for(var D=0;D<24;D++){for(var P=0;P<5;P++){for(var A=0,F=0,j=0;j<5;j++){var S=c[P+5*j];A^=S.high,F^=S.low}var N=y[P];N.high=A,N.low=F}for(var P=0;P<5;P++)for(var M=y[(P+4)%5],W=y[(P+1)%5],Q=W.high,Z=W.low,A=M.high^(Q<<1|Z>>>31),F=M.low^(Z<<1|Q>>>31),j=0;j<5;j++){var S=c[P+5*j];S.high^=A,S.low^=F}for(var L=1;L<25;L++){var A,F,S=c[L],U=S.high,H=S.low,k=d[L];k<32?(A=U<>>32-k,F=H<>>32-k):(A=H<>>64-k,F=U<>>64-k);var R=y[x[L]];R.high=A,R.low=F}var T=y[0],O=c[0];T.high=O.high,T.low=O.low;for(var P=0;P<5;P++)for(var j=0;j<5;j++){var L=P+5*j,S=c[L],ee=y[L],G=y[(P+1)%5+5*j],K=y[(P+2)%5+5*j];S.high=ee.high^~G.high&K.high,S.low=ee.low^~G.low&K.low}var S=c[0],q=m[D];S.high^=q.high,S.low^=q.low}},_doFinalize:function(){var E=this._data,p=E.words;this._nDataBytes*8;var c=E.sigBytes*8,h=this.blockSize*32;p[c>>>5]|=1<<24-c%32,p[(r.ceil((c+1)/h)*h>>>5)-1]|=128,E.sigBytes=p.length*4,this._process();for(var v=this._state,w=this.cfg.outputLength/8,B=w/8,S=[],D=0;D>>24)&16711935|(A<<24|A>>>8)&4278255360,F=(F<<8|F>>>24)&16711935|(F<<24|F>>>8)&4278255360,S.push(F),S.push(A)}return new l.init(S,w)},clone:function(){for(var E=s.clone.call(this),p=E._state=this._state.slice(0),c=0;c<25;c++)p[c]=p[c].clone();return E}});o.SHA3=s._createHelper(g),o.HmacSHA3=s._createHmacHelper(g)}(Math),n.SHA3})}(G0)),G0.exports}var Y0={exports:{}},Nc;function Cy(){return Nc||(Nc=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){/** @preserve + (c) 2012 by Cédric Mesnil. All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */return function(r){var o=n,i=o.lib,l=i.WordArray,s=i.Hasher,a=o.algo,u=l.create([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8,3,10,14,4,9,15,8,1,2,7,0,6,13,11,5,12,1,9,11,10,0,8,12,4,13,3,7,15,14,5,6,2,4,0,5,9,7,12,2,10,14,1,3,8,11,6,15,13]),f=l.create([5,14,7,0,9,2,11,4,13,6,15,8,1,10,3,12,6,11,3,7,0,13,5,10,14,15,8,12,4,9,1,2,15,5,1,3,7,14,6,9,11,8,12,2,10,0,4,13,8,6,4,1,3,11,15,0,5,12,2,13,9,7,10,14,12,15,10,4,1,5,8,7,6,2,13,14,0,3,9,11]),d=l.create([11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8,7,6,8,13,11,9,7,15,7,12,15,9,11,7,13,12,11,13,6,7,14,9,13,15,14,8,13,6,5,12,7,5,11,12,14,15,14,15,9,8,9,14,5,6,8,6,5,12,9,15,5,11,6,8,13,12,5,12,13,14,11,8,5,6]),x=l.create([8,9,9,11,13,15,15,5,7,7,8,11,14,14,12,6,9,13,15,7,12,8,9,11,7,7,12,7,6,15,13,11,9,7,15,11,8,6,6,14,12,13,5,14,13,13,7,5,15,5,8,11,14,14,6,14,6,9,12,9,12,5,15,8,8,5,12,9,12,5,14,6,8,13,6,5,15,13,11,11]),m=l.create([0,1518500249,1859775393,2400959708,2840853838]),y=l.create([1352829926,1548603684,1836072691,2053994217,0]),g=a.RIPEMD160=s.extend({_doReset:function(){this._hash=l.create([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(B,S){for(var D=0;D<16;D++){var P=S+D,A=B[P];B[P]=(A<<8|A>>>24)&16711935|(A<<24|A>>>8)&4278255360}var F=this._hash.words,j=m.words,N=y.words,M=u.words,W=f.words,Q=d.words,Z=x.words,L,U,H,k,R,T,O,ee,G,K;T=L=F[0],O=U=F[1],ee=H=F[2],G=k=F[3],K=R=F[4];for(var q,D=0;D<80;D+=1)q=L+B[S+M[D]]|0,D<16?q+=E(U,H,k)+j[0]:D<32?q+=p(U,H,k)+j[1]:D<48?q+=c(U,H,k)+j[2]:D<64?q+=h(U,H,k)+j[3]:q+=v(U,H,k)+j[4],q=q|0,q=w(q,Q[D]),q=q+R|0,L=R,R=k,k=w(H,10),H=U,U=q,q=T+B[S+W[D]]|0,D<16?q+=v(O,ee,G)+N[0]:D<32?q+=h(O,ee,G)+N[1]:D<48?q+=c(O,ee,G)+N[2]:D<64?q+=p(O,ee,G)+N[3]:q+=E(O,ee,G)+N[4],q=q|0,q=w(q,Z[D]),q=q+K|0,T=K,K=G,G=w(ee,10),ee=O,O=q;q=F[1]+H+G|0,F[1]=F[2]+k+K|0,F[2]=F[3]+R+T|0,F[3]=F[4]+L+O|0,F[4]=F[0]+U+ee|0,F[0]=q},_doFinalize:function(){var B=this._data,S=B.words,D=this._nDataBytes*8,P=B.sigBytes*8;S[P>>>5]|=128<<24-P%32,S[(P+64>>>9<<4)+14]=(D<<8|D>>>24)&16711935|(D<<24|D>>>8)&4278255360,B.sigBytes=(S.length+1)*4,this._process();for(var A=this._hash,F=A.words,j=0;j<5;j++){var N=F[j];F[j]=(N<<8|N>>>24)&16711935|(N<<24|N>>>8)&4278255360}return A},clone:function(){var B=s.clone.call(this);return B._hash=this._hash.clone(),B}});function E(B,S,D){return B^S^D}function p(B,S,D){return B&S|~B&D}function c(B,S,D){return(B|~S)^D}function h(B,S,D){return B&D|S&~D}function v(B,S,D){return B^(S|~D)}function w(B,S){return B<>>32-S}o.RIPEMD160=s._createHelper(g),o.HmacRIPEMD160=s._createHmacHelper(g)}(),n.RIPEMD160})}(Y0)),Y0.exports}var Z0={exports:{}},Tc;function Ba(){return Tc||(Tc=1,function(e,t){(function(n,r){e.exports=r(J())})(X,function(n){(function(){var r=n,o=r.lib,i=o.Base,l=r.enc,s=l.Utf8,a=r.algo;a.HMAC=i.extend({init:function(u,f){u=this._hasher=new u.init,typeof f=="string"&&(f=s.parse(f));var d=u.blockSize,x=d*4;f.sigBytes>x&&(f=u.finalize(f)),f.clamp();for(var m=this._oKey=f.clone(),y=this._iKey=f.clone(),g=m.words,E=y.words,p=0;p>>2]&255;A.sigBytes-=F}};i.BlockCipher=m.extend({cfg:m.cfg.extend({mode:E,padding:c}),reset:function(){var A;m.reset.call(this);var F=this.cfg,j=F.iv,N=F.mode;this._xformMode==this._ENC_XFORM_MODE?A=N.createEncryptor:(A=N.createDecryptor,this._minBufferSize=1),this._mode&&this._mode.__creator==A?this._mode.init(this,j&&j.words):(this._mode=A.call(N,this,j&&j.words),this._mode.__creator=A)},_doProcessBlock:function(A,F){this._mode.processBlock(A,F)},_doFinalize:function(){var A,F=this.cfg.padding;return this._xformMode==this._ENC_XFORM_MODE?(F.pad(this._data,this.blockSize),A=this._process(!0)):(A=this._process(!0),F.unpad(A)),A},blockSize:128/32});var h=i.CipherParams=l.extend({init:function(A){this.mixIn(A)},toString:function(A){return(A||this.formatter).stringify(this)}}),v=o.format={},w=v.OpenSSL={stringify:function(A){var F,j=A.ciphertext,N=A.salt;return N?F=s.create([1398893684,1701076831]).concat(N).concat(j):F=j,F.toString(f)},parse:function(A){var F,j=f.parse(A),N=j.words;return N[0]==1398893684&&N[1]==1701076831&&(F=s.create(N.slice(2,4)),N.splice(0,4),j.sigBytes-=16),h.create({ciphertext:j,salt:F})}},B=i.SerializableCipher=l.extend({cfg:l.extend({format:w}),encrypt:function(A,F,j,N){N=this.cfg.extend(N);var M=A.createEncryptor(j,N),W=M.finalize(F),Q=M.cfg;return h.create({ciphertext:W,key:j,iv:Q.iv,algorithm:A,mode:Q.mode,padding:Q.padding,blockSize:A.blockSize,formatter:N.format})},decrypt:function(A,F,j,N){N=this.cfg.extend(N),F=this._parse(F,N.format);var M=A.createDecryptor(j,N).finalize(F.ciphertext);return M},_parse:function(A,F){return typeof A=="string"?F.parse(A,this):A}}),S=o.kdf={},D=S.OpenSSL={execute:function(A,F,j,N,M){if(N||(N=s.random(64/8)),M)var W=x.create({keySize:F+j,hasher:M}).compute(A,N);else var W=x.create({keySize:F+j}).compute(A,N);var Q=s.create(W.words.slice(F),j*4);return W.sigBytes=F*4,h.create({key:W,iv:Q,salt:N})}},P=i.PasswordBasedCipher=B.extend({cfg:B.cfg.extend({kdf:D}),encrypt:function(A,F,j,N){N=this.cfg.extend(N);var M=N.kdf.execute(j,A.keySize,A.ivSize,N.salt,N.hasher);N.iv=M.iv;var W=B.encrypt.call(this,A,F,M.key,N);return W.mixIn(M),W},decrypt:function(A,F,j,N){N=this.cfg.extend(N),F=this._parse(F,N.format);var M=N.kdf.execute(j,A.keySize,A.ivSize,F.salt,N.hasher);N.iv=M.iv;var W=B.decrypt.call(this,A,F,M.key,N);return W}})}()})}(tl)),tl.exports}var nl={exports:{}},Ic;function By(){return Ic||(Ic=1,function(e,t){(function(n,r,o){e.exports=r(J(),Fe())})(X,function(n){return n.mode.CFB=function(){var r=n.lib.BlockCipherMode.extend();r.Encryptor=r.extend({processBlock:function(i,l){var s=this._cipher,a=s.blockSize;o.call(this,i,l,a,s),this._prevBlock=i.slice(l,l+a)}}),r.Decryptor=r.extend({processBlock:function(i,l){var s=this._cipher,a=s.blockSize,u=i.slice(l,l+a);o.call(this,i,l,a,s),this._prevBlock=u}});function o(i,l,s,a){var u,f=this._iv;f?(u=f.slice(0),this._iv=void 0):u=this._prevBlock,a.encryptBlock(u,0);for(var d=0;d>24&255)===255){var a=s>>16&255,u=s>>8&255,f=s&255;a===255?(a=0,u===255?(u=0,f===255?f=0:++f):++u):++a,s=0,s+=a<<16,s+=u<<8,s+=f}else s+=1<<24;return s}function i(s){return(s[0]=o(s[0]))===0&&(s[1]=o(s[1])),s}var l=r.Encryptor=r.extend({processBlock:function(s,a){var u=this._cipher,f=u.blockSize,d=this._iv,x=this._counter;d&&(x=this._counter=d.slice(0),this._iv=void 0),i(x);var m=x.slice(0);u.encryptBlock(m,0);for(var y=0;y>>2]|=s<<24-a%4*8,r.sigBytes+=s},unpad:function(r){var o=r.words[r.sigBytes-1>>>2]&255;r.sigBytes-=o}},n.pad.Ansix923})}(sl)),sl.exports}var al={exports:{}},qc;function ky(){return qc||(qc=1,function(e,t){(function(n,r,o){e.exports=r(J(),Fe())})(X,function(n){return n.pad.Iso10126={pad:function(r,o){var i=o*4,l=i-r.sigBytes%i;r.concat(n.lib.WordArray.random(l-1)).concat(n.lib.WordArray.create([l<<24],1))},unpad:function(r){var o=r.words[r.sigBytes-1>>>2]&255;r.sigBytes-=o}},n.pad.Iso10126})}(al)),al.exports}var ul={exports:{}},Vc;function Ry(){return Vc||(Vc=1,function(e,t){(function(n,r,o){e.exports=r(J(),Fe())})(X,function(n){return n.pad.Iso97971={pad:function(r,o){r.concat(n.lib.WordArray.create([2147483648],1)),n.pad.ZeroPadding.pad(r,o)},unpad:function(r){n.pad.ZeroPadding.unpad(r),r.sigBytes--}},n.pad.Iso97971})}(ul)),ul.exports}var cl={exports:{}},Kc;function Py(){return Kc||(Kc=1,function(e,t){(function(n,r,o){e.exports=r(J(),Fe())})(X,function(n){return n.pad.ZeroPadding={pad:function(r,o){var i=o*4;r.clamp(),r.sigBytes+=i-(r.sigBytes%i||i)},unpad:function(r){for(var o=r.words,i=r.sigBytes-1,i=r.sigBytes-1;i>=0;i--)if(o[i>>>2]>>>24-i%4*8&255){r.sigBytes=i+1;break}}},n.pad.ZeroPadding})}(cl)),cl.exports}var fl={exports:{}},Qc;function Oy(){return Qc||(Qc=1,function(e,t){(function(n,r,o){e.exports=r(J(),Fe())})(X,function(n){return n.pad.NoPadding={pad:function(){},unpad:function(){}},n.pad.NoPadding})}(fl)),fl.exports}var dl={exports:{}},Xc;function jy(){return Xc||(Xc=1,function(e,t){(function(n,r,o){e.exports=r(J(),Fe())})(X,function(n){return function(r){var o=n,i=o.lib,l=i.CipherParams,s=o.enc,a=s.Hex,u=o.format;u.Hex={stringify:function(f){return f.ciphertext.toString(a)},parse:function(f){var d=a.parse(f);return l.create({ciphertext:d})}}}(),n.format.Hex})}(dl)),dl.exports}var xl={exports:{}},Gc;function Ny(){return Gc||(Gc=1,function(e,t){(function(n,r,o){e.exports=r(J(),bn(),In(),pn(),Fe())})(X,function(n){return function(){var r=n,o=r.lib,i=o.BlockCipher,l=r.algo,s=[],a=[],u=[],f=[],d=[],x=[],m=[],y=[],g=[],E=[];(function(){for(var h=[],v=0;v<256;v++)v<128?h[v]=v<<1:h[v]=v<<1^283;for(var w=0,B=0,v=0;v<256;v++){var S=B^B<<1^B<<2^B<<3^B<<4;S=S>>>8^S&255^99,s[w]=S,a[S]=w;var D=h[w],P=h[D],A=h[P],F=h[S]*257^S*16843008;u[w]=F<<24|F>>>8,f[w]=F<<16|F>>>16,d[w]=F<<8|F>>>24,x[w]=F;var F=A*16843009^P*65537^D*257^w*16843008;m[S]=F<<24|F>>>8,y[S]=F<<16|F>>>16,g[S]=F<<8|F>>>24,E[S]=F,w?(w=D^h[h[h[A^D]]],B^=h[h[B]]):w=B=1}})();var p=[0,1,2,4,8,16,32,64,128,27,54],c=l.AES=i.extend({_doReset:function(){var h;if(!(this._nRounds&&this._keyPriorReset===this._key)){for(var v=this._keyPriorReset=this._key,w=v.words,B=v.sigBytes/4,S=this._nRounds=B+6,D=(S+1)*4,P=this._keySchedule=[],A=0;A6&&A%B==4&&(h=s[h>>>24]<<24|s[h>>>16&255]<<16|s[h>>>8&255]<<8|s[h&255]):(h=h<<8|h>>>24,h=s[h>>>24]<<24|s[h>>>16&255]<<16|s[h>>>8&255]<<8|s[h&255],h^=p[A/B|0]<<24),P[A]=P[A-B]^h);for(var F=this._invKeySchedule=[],j=0;j>>24]]^y[s[h>>>16&255]]^g[s[h>>>8&255]]^E[s[h&255]]}}},encryptBlock:function(h,v){this._doCryptBlock(h,v,this._keySchedule,u,f,d,x,s)},decryptBlock:function(h,v){var w=h[v+1];h[v+1]=h[v+3],h[v+3]=w,this._doCryptBlock(h,v,this._invKeySchedule,m,y,g,E,a);var w=h[v+1];h[v+1]=h[v+3],h[v+3]=w},_doCryptBlock:function(h,v,w,B,S,D,P,A){for(var F=this._nRounds,j=h[v]^w[0],N=h[v+1]^w[1],M=h[v+2]^w[2],W=h[v+3]^w[3],Q=4,Z=1;Z>>24]^S[N>>>16&255]^D[M>>>8&255]^P[W&255]^w[Q++],U=B[N>>>24]^S[M>>>16&255]^D[W>>>8&255]^P[j&255]^w[Q++],H=B[M>>>24]^S[W>>>16&255]^D[j>>>8&255]^P[N&255]^w[Q++],k=B[W>>>24]^S[j>>>16&255]^D[N>>>8&255]^P[M&255]^w[Q++];j=L,N=U,M=H,W=k}var L=(A[j>>>24]<<24|A[N>>>16&255]<<16|A[M>>>8&255]<<8|A[W&255])^w[Q++],U=(A[N>>>24]<<24|A[M>>>16&255]<<16|A[W>>>8&255]<<8|A[j&255])^w[Q++],H=(A[M>>>24]<<24|A[W>>>16&255]<<16|A[j>>>8&255]<<8|A[N&255])^w[Q++],k=(A[W>>>24]<<24|A[j>>>16&255]<<16|A[N>>>8&255]<<8|A[M&255])^w[Q++];h[v]=L,h[v+1]=U,h[v+2]=H,h[v+3]=k},keySize:256/32});r.AES=i._createHelper(c)}(),n.AES})}(xl)),xl.exports}var pl={exports:{}},Yc;function Ty(){return Yc||(Yc=1,function(e,t){(function(n,r,o){e.exports=r(J(),bn(),In(),pn(),Fe())})(X,function(n){return function(){var r=n,o=r.lib,i=o.WordArray,l=o.BlockCipher,s=r.algo,a=[57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,27,19,11,3,60,52,44,36,63,55,47,39,31,23,15,7,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,28,20,12,4],u=[14,17,11,24,1,5,3,28,15,6,21,10,23,19,12,4,26,8,16,7,27,20,13,2,41,52,31,37,47,55,30,40,51,45,33,48,44,49,39,56,34,53,46,42,50,36,29,32],f=[1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28],d=[{0:8421888,268435456:32768,536870912:8421378,805306368:2,1073741824:512,1342177280:8421890,1610612736:8389122,1879048192:8388608,2147483648:514,2415919104:8389120,2684354560:33280,2952790016:8421376,3221225472:32770,3489660928:8388610,3758096384:0,4026531840:33282,134217728:0,402653184:8421890,671088640:33282,939524096:32768,1207959552:8421888,1476395008:512,1744830464:8421378,2013265920:2,2281701376:8389120,2550136832:33280,2818572288:8421376,3087007744:8389122,3355443200:8388610,3623878656:32770,3892314112:514,4160749568:8388608,1:32768,268435457:2,536870913:8421888,805306369:8388608,1073741825:8421378,1342177281:33280,1610612737:512,1879048193:8389122,2147483649:8421890,2415919105:8421376,2684354561:8388610,2952790017:33282,3221225473:514,3489660929:8389120,3758096385:32770,4026531841:0,134217729:8421890,402653185:8421376,671088641:8388608,939524097:512,1207959553:32768,1476395009:8388610,1744830465:2,2013265921:33282,2281701377:32770,2550136833:8389122,2818572289:514,3087007745:8421888,3355443201:8389120,3623878657:0,3892314113:33280,4160749569:8421378},{0:1074282512,16777216:16384,33554432:524288,50331648:1074266128,67108864:1073741840,83886080:1074282496,100663296:1073758208,117440512:16,134217728:540672,150994944:1073758224,167772160:1073741824,184549376:540688,201326592:524304,218103808:0,234881024:16400,251658240:1074266112,8388608:1073758208,25165824:540688,41943040:16,58720256:1073758224,75497472:1074282512,92274688:1073741824,109051904:524288,125829120:1074266128,142606336:524304,159383552:0,176160768:16384,192937984:1074266112,209715200:1073741840,226492416:540672,243269632:1074282496,260046848:16400,268435456:0,285212672:1074266128,301989888:1073758224,318767104:1074282496,335544320:1074266112,352321536:16,369098752:540688,385875968:16384,402653184:16400,419430400:524288,436207616:524304,452984832:1073741840,469762048:540672,486539264:1073758208,503316480:1073741824,520093696:1074282512,276824064:540688,293601280:524288,310378496:1074266112,327155712:16384,343932928:1073758208,360710144:1074282512,377487360:16,394264576:1073741824,411041792:1074282496,427819008:1073741840,444596224:1073758224,461373440:524304,478150656:0,494927872:16400,511705088:1074266128,528482304:540672},{0:260,1048576:0,2097152:67109120,3145728:65796,4194304:65540,5242880:67108868,6291456:67174660,7340032:67174400,8388608:67108864,9437184:67174656,10485760:65792,11534336:67174404,12582912:67109124,13631488:65536,14680064:4,15728640:256,524288:67174656,1572864:67174404,2621440:0,3670016:67109120,4718592:67108868,5767168:65536,6815744:65540,7864320:260,8912896:4,9961472:256,11010048:67174400,12058624:65796,13107200:65792,14155776:67109124,15204352:67174660,16252928:67108864,16777216:67174656,17825792:65540,18874368:65536,19922944:67109120,20971520:256,22020096:67174660,23068672:67108868,24117248:0,25165824:67109124,26214400:67108864,27262976:4,28311552:65792,29360128:67174400,30408704:260,31457280:65796,32505856:67174404,17301504:67108864,18350080:260,19398656:67174656,20447232:0,21495808:65540,22544384:67109120,23592960:256,24641536:67174404,25690112:65536,26738688:67174660,27787264:65796,28835840:67108868,29884416:67109124,30932992:67174400,31981568:4,33030144:65792},{0:2151682048,65536:2147487808,131072:4198464,196608:2151677952,262144:0,327680:4198400,393216:2147483712,458752:4194368,524288:2147483648,589824:4194304,655360:64,720896:2147487744,786432:2151678016,851968:4160,917504:4096,983040:2151682112,32768:2147487808,98304:64,163840:2151678016,229376:2147487744,294912:4198400,360448:2151682112,425984:0,491520:2151677952,557056:4096,622592:2151682048,688128:4194304,753664:4160,819200:2147483648,884736:4194368,950272:4198464,1015808:2147483712,1048576:4194368,1114112:4198400,1179648:2147483712,1245184:0,1310720:4160,1376256:2151678016,1441792:2151682048,1507328:2147487808,1572864:2151682112,1638400:2147483648,1703936:2151677952,1769472:4198464,1835008:2147487744,1900544:4194304,1966080:64,2031616:4096,1081344:2151677952,1146880:2151682112,1212416:0,1277952:4198400,1343488:4194368,1409024:2147483648,1474560:2147487808,1540096:64,1605632:2147483712,1671168:4096,1736704:2147487744,1802240:2151678016,1867776:4160,1933312:2151682048,1998848:4194304,2064384:4198464},{0:128,4096:17039360,8192:262144,12288:536870912,16384:537133184,20480:16777344,24576:553648256,28672:262272,32768:16777216,36864:537133056,40960:536871040,45056:553910400,49152:553910272,53248:0,57344:17039488,61440:553648128,2048:17039488,6144:553648256,10240:128,14336:17039360,18432:262144,22528:537133184,26624:553910272,30720:536870912,34816:537133056,38912:0,43008:553910400,47104:16777344,51200:536871040,55296:553648128,59392:16777216,63488:262272,65536:262144,69632:128,73728:536870912,77824:553648256,81920:16777344,86016:553910272,90112:537133184,94208:16777216,98304:553910400,102400:553648128,106496:17039360,110592:537133056,114688:262272,118784:536871040,122880:0,126976:17039488,67584:553648256,71680:16777216,75776:17039360,79872:537133184,83968:536870912,88064:17039488,92160:128,96256:553910272,100352:262272,104448:553910400,108544:0,112640:553648128,116736:16777344,120832:262144,124928:537133056,129024:536871040},{0:268435464,256:8192,512:270532608,768:270540808,1024:268443648,1280:2097152,1536:2097160,1792:268435456,2048:0,2304:268443656,2560:2105344,2816:8,3072:270532616,3328:2105352,3584:8200,3840:270540800,128:270532608,384:270540808,640:8,896:2097152,1152:2105352,1408:268435464,1664:268443648,1920:8200,2176:2097160,2432:8192,2688:268443656,2944:270532616,3200:0,3456:270540800,3712:2105344,3968:268435456,4096:268443648,4352:270532616,4608:270540808,4864:8200,5120:2097152,5376:268435456,5632:268435464,5888:2105344,6144:2105352,6400:0,6656:8,6912:270532608,7168:8192,7424:268443656,7680:270540800,7936:2097160,4224:8,4480:2105344,4736:2097152,4992:268435464,5248:268443648,5504:8200,5760:270540808,6016:270532608,6272:270540800,6528:270532616,6784:8192,7040:2105352,7296:2097160,7552:0,7808:268435456,8064:268443656},{0:1048576,16:33555457,32:1024,48:1049601,64:34604033,80:0,96:1,112:34603009,128:33555456,144:1048577,160:33554433,176:34604032,192:34603008,208:1025,224:1049600,240:33554432,8:34603009,24:0,40:33555457,56:34604032,72:1048576,88:33554433,104:33554432,120:1025,136:1049601,152:33555456,168:34603008,184:1048577,200:1024,216:34604033,232:1,248:1049600,256:33554432,272:1048576,288:33555457,304:34603009,320:1048577,336:33555456,352:34604032,368:1049601,384:1025,400:34604033,416:1049600,432:1,448:0,464:34603008,480:33554433,496:1024,264:1049600,280:33555457,296:34603009,312:1,328:33554432,344:1048576,360:1025,376:34604032,392:33554433,408:34603008,424:0,440:34604033,456:1049601,472:1024,488:33555456,504:1048577},{0:134219808,1:131072,2:134217728,3:32,4:131104,5:134350880,6:134350848,7:2048,8:134348800,9:134219776,10:133120,11:134348832,12:2080,13:0,14:134217760,15:133152,2147483648:2048,2147483649:134350880,2147483650:134219808,2147483651:134217728,2147483652:134348800,2147483653:133120,2147483654:133152,2147483655:32,2147483656:134217760,2147483657:2080,2147483658:131104,2147483659:134350848,2147483660:0,2147483661:134348832,2147483662:134219776,2147483663:131072,16:133152,17:134350848,18:32,19:2048,20:134219776,21:134217760,22:134348832,23:131072,24:0,25:131104,26:134348800,27:134219808,28:134350880,29:133120,30:2080,31:134217728,2147483664:131072,2147483665:2048,2147483666:134348832,2147483667:133152,2147483668:32,2147483669:134348800,2147483670:134217728,2147483671:134219808,2147483672:134350880,2147483673:134217760,2147483674:134219776,2147483675:0,2147483676:133120,2147483677:2080,2147483678:131104,2147483679:134350848}],x=[4160749569,528482304,33030144,2064384,129024,8064,504,2147483679],m=s.DES=l.extend({_doReset:function(){for(var p=this._key,c=p.words,h=[],v=0;v<56;v++){var w=a[v]-1;h[v]=c[w>>>5]>>>31-w%32&1}for(var B=this._subKeys=[],S=0;S<16;S++){for(var D=B[S]=[],P=f[S],v=0;v<24;v++)D[v/6|0]|=h[(u[v]-1+P)%28]<<31-v%6,D[4+(v/6|0)]|=h[28+(u[v+24]-1+P)%28]<<31-v%6;D[0]=D[0]<<1|D[0]>>>31;for(var v=1;v<7;v++)D[v]=D[v]>>>(v-1)*4+3;D[7]=D[7]<<5|D[7]>>>27}for(var A=this._invSubKeys=[],v=0;v<16;v++)A[v]=B[15-v]},encryptBlock:function(p,c){this._doCryptBlock(p,c,this._subKeys)},decryptBlock:function(p,c){this._doCryptBlock(p,c,this._invSubKeys)},_doCryptBlock:function(p,c,h){this._lBlock=p[c],this._rBlock=p[c+1],y.call(this,4,252645135),y.call(this,16,65535),g.call(this,2,858993459),g.call(this,8,16711935),y.call(this,1,1431655765);for(var v=0;v<16;v++){for(var w=h[v],B=this._lBlock,S=this._rBlock,D=0,P=0;P<8;P++)D|=d[P][((S^w[P])&x[P])>>>0];this._lBlock=S,this._rBlock=B^D}var A=this._lBlock;this._lBlock=this._rBlock,this._rBlock=A,y.call(this,1,1431655765),g.call(this,8,16711935),g.call(this,2,858993459),y.call(this,16,65535),y.call(this,4,252645135),p[c]=this._lBlock,p[c+1]=this._rBlock},keySize:64/32,ivSize:64/32,blockSize:64/32});function y(p,c){var h=(this._lBlock>>>p^this._rBlock)&c;this._rBlock^=h,this._lBlock^=h<>>p^this._lBlock)&c;this._lBlock^=h,this._rBlock^=h<192.");var h=c.slice(0,2),v=c.length<4?c.slice(0,2):c.slice(2,4),w=c.length<6?c.slice(0,2):c.slice(4,6);this._des1=m.createEncryptor(i.create(h)),this._des2=m.createEncryptor(i.create(v)),this._des3=m.createEncryptor(i.create(w))},encryptBlock:function(p,c){this._des1.encryptBlock(p,c),this._des2.decryptBlock(p,c),this._des3.encryptBlock(p,c)},decryptBlock:function(p,c){this._des3.decryptBlock(p,c),this._des2.encryptBlock(p,c),this._des1.decryptBlock(p,c)},keySize:192/32,ivSize:64/32,blockSize:64/32});r.TripleDES=l._createHelper(E)}(),n.TripleDES})}(pl)),pl.exports}var hl={exports:{}},Zc;function Ly(){return Zc||(Zc=1,function(e,t){(function(n,r,o){e.exports=r(J(),bn(),In(),pn(),Fe())})(X,function(n){return function(){var r=n,o=r.lib,i=o.StreamCipher,l=r.algo,s=l.RC4=i.extend({_doReset:function(){for(var f=this._key,d=f.words,x=f.sigBytes,m=this._S=[],y=0;y<256;y++)m[y]=y;for(var y=0,g=0;y<256;y++){var E=y%x,p=d[E>>>2]>>>24-E%4*8&255;g=(g+m[y]+p)%256;var c=m[y];m[y]=m[g],m[g]=c}this._i=this._j=0},_doProcessBlock:function(f,d){f[d]^=a.call(this)},keySize:256/32,ivSize:0});function a(){for(var f=this._S,d=this._i,x=this._j,m=0,y=0;y<4;y++){d=(d+1)%256,x=(x+f[d])%256;var g=f[d];f[d]=f[x],f[x]=g,m|=f[(f[d]+f[x])%256]<<24-y*8}return this._i=d,this._j=x,m}r.RC4=i._createHelper(s);var u=l.RC4Drop=s.extend({cfg:s.cfg.extend({drop:192}),_doReset:function(){s._doReset.call(this);for(var f=this.cfg.drop;f>0;f--)a.call(this)}});r.RC4Drop=i._createHelper(u)}(),n.RC4})}(hl)),hl.exports}var vl={exports:{}},Jc;function zy(){return Jc||(Jc=1,function(e,t){(function(n,r,o){e.exports=r(J(),bn(),In(),pn(),Fe())})(X,function(n){return function(){var r=n,o=r.lib,i=o.StreamCipher,l=r.algo,s=[],a=[],u=[],f=l.Rabbit=i.extend({_doReset:function(){for(var x=this._key.words,m=this.cfg.iv,y=0;y<4;y++)x[y]=(x[y]<<8|x[y]>>>24)&16711935|(x[y]<<24|x[y]>>>8)&4278255360;var g=this._X=[x[0],x[3]<<16|x[2]>>>16,x[1],x[0]<<16|x[3]>>>16,x[2],x[1]<<16|x[0]>>>16,x[3],x[2]<<16|x[1]>>>16],E=this._C=[x[2]<<16|x[2]>>>16,x[0]&4294901760|x[1]&65535,x[3]<<16|x[3]>>>16,x[1]&4294901760|x[2]&65535,x[0]<<16|x[0]>>>16,x[2]&4294901760|x[3]&65535,x[1]<<16|x[1]>>>16,x[3]&4294901760|x[0]&65535];this._b=0;for(var y=0;y<4;y++)d.call(this);for(var y=0;y<8;y++)E[y]^=g[y+4&7];if(m){var p=m.words,c=p[0],h=p[1],v=(c<<8|c>>>24)&16711935|(c<<24|c>>>8)&4278255360,w=(h<<8|h>>>24)&16711935|(h<<24|h>>>8)&4278255360,B=v>>>16|w&4294901760,S=w<<16|v&65535;E[0]^=v,E[1]^=B,E[2]^=w,E[3]^=S,E[4]^=v,E[5]^=B,E[6]^=w,E[7]^=S;for(var y=0;y<4;y++)d.call(this)}},_doProcessBlock:function(x,m){var y=this._X;d.call(this),s[0]=y[0]^y[5]>>>16^y[3]<<16,s[1]=y[2]^y[7]>>>16^y[5]<<16,s[2]=y[4]^y[1]>>>16^y[7]<<16,s[3]=y[6]^y[3]>>>16^y[1]<<16;for(var g=0;g<4;g++)s[g]=(s[g]<<8|s[g]>>>24)&16711935|(s[g]<<24|s[g]>>>8)&4278255360,x[m+g]^=s[g]},blockSize:128/32,ivSize:64/32});function d(){for(var x=this._X,m=this._C,y=0;y<8;y++)a[y]=m[y];m[0]=m[0]+1295307597+this._b|0,m[1]=m[1]+3545052371+(m[0]>>>0>>0?1:0)|0,m[2]=m[2]+886263092+(m[1]>>>0>>0?1:0)|0,m[3]=m[3]+1295307597+(m[2]>>>0>>0?1:0)|0,m[4]=m[4]+3545052371+(m[3]>>>0>>0?1:0)|0,m[5]=m[5]+886263092+(m[4]>>>0>>0?1:0)|0,m[6]=m[6]+1295307597+(m[5]>>>0>>0?1:0)|0,m[7]=m[7]+3545052371+(m[6]>>>0>>0?1:0)|0,this._b=m[7]>>>0>>0?1:0;for(var y=0;y<8;y++){var g=x[y]+m[y],E=g&65535,p=g>>>16,c=((E*E>>>17)+E*p>>>15)+p*p,h=((g&4294901760)*g|0)+((g&65535)*g|0);u[y]=c^h}x[0]=u[0]+(u[7]<<16|u[7]>>>16)+(u[6]<<16|u[6]>>>16)|0,x[1]=u[1]+(u[0]<<8|u[0]>>>24)+u[7]|0,x[2]=u[2]+(u[1]<<16|u[1]>>>16)+(u[0]<<16|u[0]>>>16)|0,x[3]=u[3]+(u[2]<<8|u[2]>>>24)+u[1]|0,x[4]=u[4]+(u[3]<<16|u[3]>>>16)+(u[2]<<16|u[2]>>>16)|0,x[5]=u[5]+(u[4]<<8|u[4]>>>24)+u[3]|0,x[6]=u[6]+(u[5]<<16|u[5]>>>16)+(u[4]<<16|u[4]>>>16)|0,x[7]=u[7]+(u[6]<<8|u[6]>>>24)+u[5]|0}r.Rabbit=i._createHelper(f)}(),n.Rabbit})}(vl)),vl.exports}var ml={exports:{}},ef;function by(){return ef||(ef=1,function(e,t){(function(n,r,o){e.exports=r(J(),bn(),In(),pn(),Fe())})(X,function(n){return function(){var r=n,o=r.lib,i=o.StreamCipher,l=r.algo,s=[],a=[],u=[],f=l.RabbitLegacy=i.extend({_doReset:function(){var x=this._key.words,m=this.cfg.iv,y=this._X=[x[0],x[3]<<16|x[2]>>>16,x[1],x[0]<<16|x[3]>>>16,x[2],x[1]<<16|x[0]>>>16,x[3],x[2]<<16|x[1]>>>16],g=this._C=[x[2]<<16|x[2]>>>16,x[0]&4294901760|x[1]&65535,x[3]<<16|x[3]>>>16,x[1]&4294901760|x[2]&65535,x[0]<<16|x[0]>>>16,x[2]&4294901760|x[3]&65535,x[1]<<16|x[1]>>>16,x[3]&4294901760|x[0]&65535];this._b=0;for(var E=0;E<4;E++)d.call(this);for(var E=0;E<8;E++)g[E]^=y[E+4&7];if(m){var p=m.words,c=p[0],h=p[1],v=(c<<8|c>>>24)&16711935|(c<<24|c>>>8)&4278255360,w=(h<<8|h>>>24)&16711935|(h<<24|h>>>8)&4278255360,B=v>>>16|w&4294901760,S=w<<16|v&65535;g[0]^=v,g[1]^=B,g[2]^=w,g[3]^=S,g[4]^=v,g[5]^=B,g[6]^=w,g[7]^=S;for(var E=0;E<4;E++)d.call(this)}},_doProcessBlock:function(x,m){var y=this._X;d.call(this),s[0]=y[0]^y[5]>>>16^y[3]<<16,s[1]=y[2]^y[7]>>>16^y[5]<<16,s[2]=y[4]^y[1]>>>16^y[7]<<16,s[3]=y[6]^y[3]>>>16^y[1]<<16;for(var g=0;g<4;g++)s[g]=(s[g]<<8|s[g]>>>24)&16711935|(s[g]<<24|s[g]>>>8)&4278255360,x[m+g]^=s[g]},blockSize:128/32,ivSize:64/32});function d(){for(var x=this._X,m=this._C,y=0;y<8;y++)a[y]=m[y];m[0]=m[0]+1295307597+this._b|0,m[1]=m[1]+3545052371+(m[0]>>>0>>0?1:0)|0,m[2]=m[2]+886263092+(m[1]>>>0>>0?1:0)|0,m[3]=m[3]+1295307597+(m[2]>>>0>>0?1:0)|0,m[4]=m[4]+3545052371+(m[3]>>>0>>0?1:0)|0,m[5]=m[5]+886263092+(m[4]>>>0>>0?1:0)|0,m[6]=m[6]+1295307597+(m[5]>>>0>>0?1:0)|0,m[7]=m[7]+3545052371+(m[6]>>>0>>0?1:0)|0,this._b=m[7]>>>0>>0?1:0;for(var y=0;y<8;y++){var g=x[y]+m[y],E=g&65535,p=g>>>16,c=((E*E>>>17)+E*p>>>15)+p*p,h=((g&4294901760)*g|0)+((g&65535)*g|0);u[y]=c^h}x[0]=u[0]+(u[7]<<16|u[7]>>>16)+(u[6]<<16|u[6]>>>16)|0,x[1]=u[1]+(u[0]<<8|u[0]>>>24)+u[7]|0,x[2]=u[2]+(u[1]<<16|u[1]>>>16)+(u[0]<<16|u[0]>>>16)|0,x[3]=u[3]+(u[2]<<8|u[2]>>>24)+u[1]|0,x[4]=u[4]+(u[3]<<16|u[3]>>>16)+(u[2]<<16|u[2]>>>16)|0,x[5]=u[5]+(u[4]<<8|u[4]>>>24)+u[3]|0,x[6]=u[6]+(u[5]<<16|u[5]>>>16)+(u[4]<<16|u[4]>>>16)|0,x[7]=u[7]+(u[6]<<8|u[6]>>>24)+u[5]|0}r.RabbitLegacy=i._createHelper(f)}(),n.RabbitLegacy})}(ml)),ml.exports}var yl={exports:{}},tf;function Iy(){return tf||(tf=1,function(e,t){(function(n,r,o){e.exports=r(J(),bn(),In(),pn(),Fe())})(X,function(n){return function(){var r=n,o=r.lib,i=o.BlockCipher,l=r.algo;const s=16,a=[608135816,2242054355,320440878,57701188,2752067618,698298832,137296536,3964562569,1160258022,953160567,3193202383,887688300,3232508343,3380367581,1065670069,3041331479,2450970073,2306472731],u=[[3509652390,2564797868,805139163,3491422135,3101798381,1780907670,3128725573,4046225305,614570311,3012652279,134345442,2240740374,1667834072,1901547113,2757295779,4103290238,227898511,1921955416,1904987480,2182433518,2069144605,3260701109,2620446009,720527379,3318853667,677414384,3393288472,3101374703,2390351024,1614419982,1822297739,2954791486,3608508353,3174124327,2024746970,1432378464,3864339955,2857741204,1464375394,1676153920,1439316330,715854006,3033291828,289532110,2706671279,2087905683,3018724369,1668267050,732546397,1947742710,3462151702,2609353502,2950085171,1814351708,2050118529,680887927,999245976,1800124847,3300911131,1713906067,1641548236,4213287313,1216130144,1575780402,4018429277,3917837745,3693486850,3949271944,596196993,3549867205,258830323,2213823033,772490370,2760122372,1774776394,2652871518,566650946,4142492826,1728879713,2882767088,1783734482,3629395816,2517608232,2874225571,1861159788,326777828,3124490320,2130389656,2716951837,967770486,1724537150,2185432712,2364442137,1164943284,2105845187,998989502,3765401048,2244026483,1075463327,1455516326,1322494562,910128902,469688178,1117454909,936433444,3490320968,3675253459,1240580251,122909385,2157517691,634681816,4142456567,3825094682,3061402683,2540495037,79693498,3249098678,1084186820,1583128258,426386531,1761308591,1047286709,322548459,995290223,1845252383,2603652396,3431023940,2942221577,3202600964,3727903485,1712269319,422464435,3234572375,1170764815,3523960633,3117677531,1434042557,442511882,3600875718,1076654713,1738483198,4213154764,2393238008,3677496056,1014306527,4251020053,793779912,2902807211,842905082,4246964064,1395751752,1040244610,2656851899,3396308128,445077038,3742853595,3577915638,679411651,2892444358,2354009459,1767581616,3150600392,3791627101,3102740896,284835224,4246832056,1258075500,768725851,2589189241,3069724005,3532540348,1274779536,3789419226,2764799539,1660621633,3471099624,4011903706,913787905,3497959166,737222580,2514213453,2928710040,3937242737,1804850592,3499020752,2949064160,2386320175,2390070455,2415321851,4061277028,2290661394,2416832540,1336762016,1754252060,3520065937,3014181293,791618072,3188594551,3933548030,2332172193,3852520463,3043980520,413987798,3465142937,3030929376,4245938359,2093235073,3534596313,375366246,2157278981,2479649556,555357303,3870105701,2008414854,3344188149,4221384143,3956125452,2067696032,3594591187,2921233993,2428461,544322398,577241275,1471733935,610547355,4027169054,1432588573,1507829418,2025931657,3646575487,545086370,48609733,2200306550,1653985193,298326376,1316178497,3007786442,2064951626,458293330,2589141269,3591329599,3164325604,727753846,2179363840,146436021,1461446943,4069977195,705550613,3059967265,3887724982,4281599278,3313849956,1404054877,2845806497,146425753,1854211946],[1266315497,3048417604,3681880366,3289982499,290971e4,1235738493,2632868024,2414719590,3970600049,1771706367,1449415276,3266420449,422970021,1963543593,2690192192,3826793022,1062508698,1531092325,1804592342,2583117782,2714934279,4024971509,1294809318,4028980673,1289560198,2221992742,1669523910,35572830,157838143,1052438473,1016535060,1802137761,1753167236,1386275462,3080475397,2857371447,1040679964,2145300060,2390574316,1461121720,2956646967,4031777805,4028374788,33600511,2920084762,1018524850,629373528,3691585981,3515945977,2091462646,2486323059,586499841,988145025,935516892,3367335476,2599673255,2839830854,265290510,3972581182,2759138881,3795373465,1005194799,847297441,406762289,1314163512,1332590856,1866599683,4127851711,750260880,613907577,1450815602,3165620655,3734664991,3650291728,3012275730,3704569646,1427272223,778793252,1343938022,2676280711,2052605720,1946737175,3164576444,3914038668,3967478842,3682934266,1661551462,3294938066,4011595847,840292616,3712170807,616741398,312560963,711312465,1351876610,322626781,1910503582,271666773,2175563734,1594956187,70604529,3617834859,1007753275,1495573769,4069517037,2549218298,2663038764,504708206,2263041392,3941167025,2249088522,1514023603,1998579484,1312622330,694541497,2582060303,2151582166,1382467621,776784248,2618340202,3323268794,2497899128,2784771155,503983604,4076293799,907881277,423175695,432175456,1378068232,4145222326,3954048622,3938656102,3820766613,2793130115,2977904593,26017576,3274890735,3194772133,1700274565,1756076034,4006520079,3677328699,720338349,1533947780,354530856,688349552,3973924725,1637815568,332179504,3949051286,53804574,2852348879,3044236432,1282449977,3583942155,3416972820,4006381244,1617046695,2628476075,3002303598,1686838959,431878346,2686675385,1700445008,1080580658,1009431731,832498133,3223435511,2605976345,2271191193,2516031870,1648197032,4164389018,2548247927,300782431,375919233,238389289,3353747414,2531188641,2019080857,1475708069,455242339,2609103871,448939670,3451063019,1395535956,2413381860,1841049896,1491858159,885456874,4264095073,4001119347,1565136089,3898914787,1108368660,540939232,1173283510,2745871338,3681308437,4207628240,3343053890,4016749493,1699691293,1103962373,3625875870,2256883143,3830138730,1031889488,3479347698,1535977030,4236805024,3251091107,2132092099,1774941330,1199868427,1452454533,157007616,2904115357,342012276,595725824,1480756522,206960106,497939518,591360097,863170706,2375253569,3596610801,1814182875,2094937945,3421402208,1082520231,3463918190,2785509508,435703966,3908032597,1641649973,2842273706,3305899714,1510255612,2148256476,2655287854,3276092548,4258621189,236887753,3681803219,274041037,1734335097,3815195456,3317970021,1899903192,1026095262,4050517792,356393447,2410691914,3873677099,3682840055],[3913112168,2491498743,4132185628,2489919796,1091903735,1979897079,3170134830,3567386728,3557303409,857797738,1136121015,1342202287,507115054,2535736646,337727348,3213592640,1301675037,2528481711,1895095763,1721773893,3216771564,62756741,2142006736,835421444,2531993523,1442658625,3659876326,2882144922,676362277,1392781812,170690266,3921047035,1759253602,3611846912,1745797284,664899054,1329594018,3901205900,3045908486,2062866102,2865634940,3543621612,3464012697,1080764994,553557557,3656615353,3996768171,991055499,499776247,1265440854,648242737,3940784050,980351604,3713745714,1749149687,3396870395,4211799374,3640570775,1161844396,3125318951,1431517754,545492359,4268468663,3499529547,1437099964,2702547544,3433638243,2581715763,2787789398,1060185593,1593081372,2418618748,4260947970,69676912,2159744348,86519011,2512459080,3838209314,1220612927,3339683548,133810670,1090789135,1078426020,1569222167,845107691,3583754449,4072456591,1091646820,628848692,1613405280,3757631651,526609435,236106946,48312990,2942717905,3402727701,1797494240,859738849,992217954,4005476642,2243076622,3870952857,3732016268,765654824,3490871365,2511836413,1685915746,3888969200,1414112111,2273134842,3281911079,4080962846,172450625,2569994100,980381355,4109958455,2819808352,2716589560,2568741196,3681446669,3329971472,1835478071,660984891,3704678404,4045999559,3422617507,3040415634,1762651403,1719377915,3470491036,2693910283,3642056355,3138596744,1364962596,2073328063,1983633131,926494387,3423689081,2150032023,4096667949,1749200295,3328846651,309677260,2016342300,1779581495,3079819751,111262694,1274766160,443224088,298511866,1025883608,3806446537,1145181785,168956806,3641502830,3584813610,1689216846,3666258015,3200248200,1692713982,2646376535,4042768518,1618508792,1610833997,3523052358,4130873264,2001055236,3610705100,2202168115,4028541809,2961195399,1006657119,2006996926,3186142756,1430667929,3210227297,1314452623,4074634658,4101304120,2273951170,1399257539,3367210612,3027628629,1190975929,2062231137,2333990788,2221543033,2438960610,1181637006,548689776,2362791313,3372408396,3104550113,3145860560,296247880,1970579870,3078560182,3769228297,1714227617,3291629107,3898220290,166772364,1251581989,493813264,448347421,195405023,2709975567,677966185,3703036547,1463355134,2715995803,1338867538,1343315457,2802222074,2684532164,233230375,2599980071,2000651841,3277868038,1638401717,4028070440,3237316320,6314154,819756386,300326615,590932579,1405279636,3267499572,3150704214,2428286686,3959192993,3461946742,1862657033,1266418056,963775037,2089974820,2263052895,1917689273,448879540,3550394620,3981727096,150775221,3627908307,1303187396,508620638,2975983352,2726630617,1817252668,1876281319,1457606340,908771278,3720792119,3617206836,2455994898,1729034894,1080033504],[976866871,3556439503,2881648439,1522871579,1555064734,1336096578,3548522304,2579274686,3574697629,3205460757,3593280638,3338716283,3079412587,564236357,2993598910,1781952180,1464380207,3163844217,3332601554,1699332808,1393555694,1183702653,3581086237,1288719814,691649499,2847557200,2895455976,3193889540,2717570544,1781354906,1676643554,2592534050,3230253752,1126444790,2770207658,2633158820,2210423226,2615765581,2414155088,3127139286,673620729,2805611233,1269405062,4015350505,3341807571,4149409754,1057255273,2012875353,2162469141,2276492801,2601117357,993977747,3918593370,2654263191,753973209,36408145,2530585658,25011837,3520020182,2088578344,530523599,2918365339,1524020338,1518925132,3760827505,3759777254,1202760957,3985898139,3906192525,674977740,4174734889,2031300136,2019492241,3983892565,4153806404,3822280332,352677332,2297720250,60907813,90501309,3286998549,1016092578,2535922412,2839152426,457141659,509813237,4120667899,652014361,1966332200,2975202805,55981186,2327461051,676427537,3255491064,2882294119,3433927263,1307055953,942726286,933058658,2468411793,3933900994,4215176142,1361170020,2001714738,2830558078,3274259782,1222529897,1679025792,2729314320,3714953764,1770335741,151462246,3013232138,1682292957,1483529935,471910574,1539241949,458788160,3436315007,1807016891,3718408830,978976581,1043663428,3165965781,1927990952,4200891579,2372276910,3208408903,3533431907,1412390302,2931980059,4132332400,1947078029,3881505623,4168226417,2941484381,1077988104,1320477388,886195818,18198404,3786409e3,2509781533,112762804,3463356488,1866414978,891333506,18488651,661792760,1628790961,3885187036,3141171499,876946877,2693282273,1372485963,791857591,2686433993,3759982718,3167212022,3472953795,2716379847,445679433,3561995674,3504004811,3574258232,54117162,3331405415,2381918588,3769707343,4154350007,1140177722,4074052095,668550556,3214352940,367459370,261225585,2610173221,4209349473,3468074219,3265815641,314222801,3066103646,3808782860,282218597,3406013506,3773591054,379116347,1285071038,846784868,2669647154,3771962079,3550491691,2305946142,453669953,1268987020,3317592352,3279303384,3744833421,2610507566,3859509063,266596637,3847019092,517658769,3462560207,3443424879,370717030,4247526661,2224018117,4143653529,4112773975,2788324899,2477274417,1456262402,2901442914,1517677493,1846949527,2295493580,3734397586,2176403920,1280348187,1908823572,3871786941,846861322,1172426758,3287448474,3383383037,1655181056,3139813346,901632758,1897031941,2986607138,3066810236,3447102507,1393639104,373351379,950779232,625454576,3124240540,4148612726,2007998917,544563296,2244738638,2330496472,2058025392,1291430526,424198748,50039436,29584100,3605783033,2429876329,2791104160,1057563949,3255363231,3075367218,3463963227,1469046755,985887462]];var f={pbox:[],sbox:[]};function d(E,p){let c=p>>24&255,h=p>>16&255,v=p>>8&255,w=p&255,B=E.sbox[0][c]+E.sbox[1][h];return B=B^E.sbox[2][v],B=B+E.sbox[3][w],B}function x(E,p,c){let h=p,v=c,w;for(let B=0;B1;--B)h=h^E.pbox[B],v=d(E,h)^v,w=h,h=v,v=w;return w=h,h=v,v=w,v=v^E.pbox[1],h=h^E.pbox[0],{left:h,right:v}}function y(E,p,c){for(let S=0;S<4;S++){E.sbox[S]=[];for(let D=0;D<256;D++)E.sbox[S][D]=u[S][D]}let h=0;for(let S=0;S=c&&(h=0);let v=0,w=0,B=0;for(let S=0;St(u.target.value),placeholder:"账号",style:rf}),C.jsx("input",{value:n,onChange:u=>r(u.target.value),type:"password",placeholder:"密码",style:rf}),o&&C.jsx("div",{style:{color:"#e24b4a"},children:o}),C.jsx("button",{type:"submit",style:Vy,children:"登录"}),C.jsx("div",{style:{fontSize:12,color:"#888"},children:"默认 admin / 123456"})]})})}const Wy={minHeight:"100vh",display:"flex",alignItems:"center",justifyContent:"center",background:"#0f1419",color:"#eee"},qy={display:"flex",flexDirection:"column",gap:12,padding:24,background:"#1a1f26",borderRadius:12,width:300},rf={padding:8,borderRadius:6,border:"1px solid #333",background:"#0f1419",color:"#eee"},Vy={padding:10,borderRadius:6,border:0,background:"#185fa5",color:"#fff",cursor:"pointer"},Un={minHeight:"100vh",padding:24,background:"#0f1419",color:"#eee",fontFamily:"system-ui, sans-serif"},ct={background:"#1a1f26",borderRadius:12,padding:20},be={padding:"8px 14px",borderRadius:6,border:0,background:"#185fa5",color:"#fff",cursor:"pointer"},wr={...be,background:"#a1322b"},yt={...be,background:"#2a3340"},de={padding:8,borderRadius:6,border:"1px solid #333",background:"#0f1419",color:"#eee"},Br={width:"100%",borderCollapse:"collapse",marginTop:12},ie={textAlign:"left",padding:"8px",borderBottom:"1px solid #2a3340",color:"#9aa7b5"},re={padding:"8px",borderBottom:"1px solid #1f2630"};function Ky(){const e=xa(),[t,n]=z.useState([]),[r,o]=z.useState(null);z.useEffect(()=>{cy().then(s=>{n(s.menuList||[]),o(s.userInfo)}).catch(()=>{})},[]);function i(s){s&&e("/"+s)}function l(){ms(),location.reload()}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{children:"SSW JNPF Lite · React"}),C.jsxs("div",{style:{color:"#9aa7b5"},children:[r==null?void 0:r.userAccount," ",r!=null&&r.isAdministrator?"(管理员)":""]}),C.jsx("h3",{style:{marginTop:16},children:"功能菜单"}),t.map(s=>C.jsxs("div",{style:{marginBottom:10},children:[C.jsx("div",{style:{color:"#9aa7b5",fontSize:12},children:s.fullName}),C.jsx("div",{style:{display:"flex",gap:8,flexWrap:"wrap",marginTop:4},children:s.children.map(a=>C.jsx("button",{style:yt,onClick:()=>i(a.urlAddress),children:a.fullName},a.id))})]},s.id)),C.jsx("button",{style:{...be,background:"#712b13",marginTop:12},onClick:l,children:"退出"})]})})}function Qy(){const[e,t]=z.useState([]),[n,r]=z.useState("");async function o(){const s=await oe.get("/ssw/demo/DemoItem/List");t(s||[])}z.useEffect(()=>{o()},[]);async function i(){n&&(await oe.post("/ssw/demo/DemoItem/Save",{title:n,status:"草稿"}),r(""),o())}async function l(s){await oe.delete(`/ssw/demo/DemoItem/Delete?id=${s}`),o()}return C.jsx("div",{style:Xy,children:C.jsxs("div",{style:Gy,children:[C.jsx("h2",{children:"DemoItem"}),C.jsxs("div",{style:{display:"flex",gap:8},children:[C.jsx("input",{value:n,onChange:s=>r(s.target.value),placeholder:"标题",style:Yy}),C.jsx("button",{style:of,onClick:i,children:"新增"})]}),C.jsx("ul",{children:e.map(s=>C.jsxs("li",{style:{display:"flex",gap:12,alignItems:"center"},children:[C.jsxs("span",{children:[s.title,"(",s.status,")"]}),C.jsx("button",{style:{...of,background:"#712b13"},onClick:()=>l(s.id),children:"删除"})]},s.id))}),C.jsx("button",{style:Zy,onClick:()=>history.back(),children:"返回"})]})})}const Xy={minHeight:"100vh",padding:40,background:"#0f1419",color:"#eee"},Gy={display:"flex",flexDirection:"column",gap:12,padding:24,background:"#1a1f26",borderRadius:12,minWidth:360},Yy={padding:8,borderRadius:6,border:"1px solid #333",background:"#0f1419",color:"#eee"},of={padding:8,borderRadius:6,border:0,background:"#185fa5",color:"#fff",cursor:"pointer"},Zy={padding:8,background:"transparent",border:0,color:"#85b7eb",cursor:"pointer",textAlign:"left"},Jy=()=>oe.get("/ssw/shop/Product/List"),eg=e=>oe.post("/ssw/shop/Product/Save",e),tg=e=>oe.delete(`/ssw/shop/Product/Delete?id=${e}`);function ng(){const[e,t]=z.useState([]),[n,r]=z.useState(""),[o,i]=z.useState("");async function l(){const u=await Jy();t(u||[])}z.useEffect(()=>{l()},[]);async function s(){n&&(await eg({title:n,price:o||"0.00"}),r(""),i(""),l())}async function a(u){await tg(u),l()}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{style:{margin:0},children:"产品管理"}),C.jsxs("div",{style:{display:"flex",gap:8,margin:"12px 0"},children:[C.jsx("input",{value:n,onChange:u=>r(u.target.value),placeholder:"产品名称",style:de}),C.jsx("input",{value:o,onChange:u=>i(u.target.value),placeholder:"价格",style:{...de,width:100}}),C.jsx("button",{style:be,onClick:s,children:"新增"}),C.jsx("button",{style:{...be,background:"#2a3340"},onClick:()=>history.back(),children:"返回"})]}),C.jsxs("table",{style:Br,children:[C.jsx("thead",{children:C.jsxs("tr",{children:[C.jsx("th",{style:ie,children:"名称"}),C.jsx("th",{style:ie,children:"价格"}),C.jsx("th",{style:ie,children:"操作"})]})}),C.jsxs("tbody",{children:[e.map(u=>C.jsxs("tr",{children:[C.jsx("td",{style:re,children:u.title}),C.jsxs("td",{style:re,children:["¥",u.price]}),C.jsx("td",{style:re,children:C.jsx("button",{style:wr,onClick:()=>a(u.id),children:"删除"})})]},u.id)),e.length===0&&C.jsx("tr",{children:C.jsx("td",{style:re,colSpan:3,children:"暂无数据"})})]})]})]})})}const rg=()=>oe.get("/ssw/books/Book/List"),og=e=>oe.post("/ssw/books/Book/Save",e),ig=e=>oe.delete(`/ssw/books/Book/Delete?id=${e}`);function lg(){const[e,t]=z.useState([]),[n,r]=z.useState({title:"",author:"",isbn:"",category:"",price:"",stock:""});async function o(){const a=await rg();t(a||[])}z.useEffect(()=>{o()},[]);function i(a,u){r(f=>({...f,[a]:u}))}async function l(){n.title&&(await og({title:n.title,author:n.author||void 0,isbn:n.isbn||void 0,category:n.category||void 0,price:n.price||"0.00",stock:n.stock?Number(n.stock):0}),r({title:"",author:"",isbn:"",category:"",price:"",stock:""}),o())}async function s(a){await ig(a),o()}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{style:{margin:0},children:"图书超市"}),C.jsxs("div",{style:{display:"grid",gridTemplateColumns:"repeat(3, minmax(140px, 1fr))",gap:8,margin:"12px 0"},children:[C.jsx("input",{value:n.title,onChange:a=>i("title",a.target.value),placeholder:"书名",style:de}),C.jsx("input",{value:n.author,onChange:a=>i("author",a.target.value),placeholder:"作者",style:de}),C.jsx("input",{value:n.isbn,onChange:a=>i("isbn",a.target.value),placeholder:"ISBN",style:de}),C.jsx("input",{value:n.category,onChange:a=>i("category",a.target.value),placeholder:"分类",style:de}),C.jsx("input",{value:n.price,onChange:a=>i("price",a.target.value),placeholder:"价格",style:de}),C.jsx("input",{value:n.stock,onChange:a=>i("stock",a.target.value),placeholder:"库存",style:de})]}),C.jsxs("div",{style:{display:"flex",gap:8},children:[C.jsx("button",{style:be,onClick:l,children:"新增"}),C.jsx("button",{style:{...be,background:"#2a3340"},onClick:()=>history.back(),children:"返回"})]}),C.jsxs("table",{style:Br,children:[C.jsx("thead",{children:C.jsxs("tr",{children:[C.jsx("th",{style:ie,children:"书名"}),C.jsx("th",{style:ie,children:"作者"}),C.jsx("th",{style:ie,children:"ISBN"}),C.jsx("th",{style:ie,children:"分类"}),C.jsx("th",{style:ie,children:"价格"}),C.jsx("th",{style:ie,children:"库存"}),C.jsx("th",{style:ie,children:"操作"})]})}),C.jsxs("tbody",{children:[e.map(a=>C.jsxs("tr",{children:[C.jsx("td",{style:re,children:a.title}),C.jsx("td",{style:re,children:a.author}),C.jsx("td",{style:re,children:a.isbn}),C.jsx("td",{style:re,children:a.category}),C.jsxs("td",{style:re,children:["¥",a.price]}),C.jsx("td",{style:re,children:a.stock}),C.jsx("td",{style:re,children:C.jsx("button",{style:wr,onClick:()=>s(a.id),children:"删除"})})]},a.id)),e.length===0&&C.jsx("tr",{children:C.jsx("td",{style:re,colSpan:7,children:"暂无数据"})})]})]})]})})}const sg=()=>oe.get("/ssw/sys/User/List"),ag=e=>oe.post("/ssw/sys/User/Save",e),ug=e=>oe.delete(`/ssw/sys/User/Delete?id=${e}`),hp=()=>oe.get("/ssw/sys/Role/List"),cg=e=>oe.post("/ssw/sys/Role/Save",e),fg=e=>oe.delete(`/ssw/sys/Role/Delete?id=${e}`),dg=e=>oe.get(`/ssw/sys/Role/Modules?roleId=${e}`),xg=()=>oe.get("/ssw/sys/Organize/List"),pg=e=>oe.post("/ssw/sys/Organize/Save",e),hg=e=>oe.delete(`/ssw/sys/Organize/Delete?id=${e}`),vp=()=>oe.get("/ssw/sys/Module/List"),vg=e=>oe.post("/ssw/sys/Module/Save",e),mg=e=>oe.delete(`/ssw/sys/Module/Delete?id=${e}`),yg=(e,t)=>oe.put(`/permission/Authority/Data/${e}`,{objectType:"role",module:t});function gg(){const[e,t]=z.useState([]),[n,r]=z.useState([]),[o,i]=z.useState(null),[l,s]=z.useState({account:"",realName:"",password:"",isAdministrator:!1,roleIds:[]});async function a(){t(await sg()),r(await hp())}z.useEffect(()=>{a()},[]);function u(x){s(x?{account:x.account,realName:x.realName||"",password:"",isAdministrator:x.isAdministrator===1,roleIds:x.roleIds||[]}:{account:"",realName:"",password:"",isAdministrator:!1,roleIds:[]}),i(x||{})}async function f(){if(!l.account)return alert("账号必填");await ag({...l,id:o==null?void 0:o.id}),i(null),await a()}async function d(x){confirm("确认删除该用户?")&&(await ug(x),await a())}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{children:"用户管理"}),C.jsx("button",{style:be,onClick:()=>u(),children:"新增用户"}),C.jsxs("table",{style:Br,children:[C.jsx("thead",{children:C.jsxs("tr",{children:[C.jsx("th",{style:ie,children:"账号"}),C.jsx("th",{style:ie,children:"姓名"}),C.jsx("th",{style:ie,children:"角色"}),C.jsx("th",{style:ie,children:"管理员"}),C.jsx("th",{style:ie,children:"操作"})]})}),C.jsx("tbody",{children:e.map(x=>C.jsxs("tr",{children:[C.jsx("td",{style:re,children:x.account}),C.jsx("td",{style:re,children:x.realName}),C.jsx("td",{style:re,children:(x.roleNames||[]).join(",")}),C.jsx("td",{style:re,children:x.isAdministrator===1?"是":"否"}),C.jsxs("td",{style:re,children:[C.jsx("button",{style:yt,onClick:()=>u(x),children:"编辑"})," ",C.jsx("button",{style:wr,onClick:()=>d(x.id),children:"删除"})]})]},x.id))})]}),o&&C.jsxs("div",{style:{...ct,marginTop:16},children:[C.jsxs("h3",{children:[o.id?"编辑":"新增","用户"]}),C.jsxs("div",{style:{display:"flex",gap:8,flexWrap:"wrap",alignItems:"center"},children:[C.jsx("input",{style:de,placeholder:"账号",value:l.account,onChange:x=>s({...l,account:x.target.value})}),C.jsx("input",{style:de,placeholder:"姓名",value:l.realName,onChange:x=>s({...l,realName:x.target.value})}),C.jsx("input",{style:de,placeholder:"密码(留空不改)",type:"password",value:l.password,onChange:x=>s({...l,password:x.target.value})}),C.jsxs("label",{children:[C.jsx("input",{type:"checkbox",checked:l.isAdministrator,onChange:x=>s({...l,isAdministrator:x.target.checked})})," ","管理员"]}),C.jsx("select",{multiple:!0,style:de,value:l.roleIds,onChange:x=>s({...l,roleIds:Array.from(x.target.selectedOptions).map(m=>m.value)}),children:n.map(x=>C.jsx("option",{value:x.id,children:x.fullName},x.id))})]}),C.jsxs("div",{style:{marginTop:12,display:"flex",gap:8},children:[C.jsx("button",{style:be,onClick:f,children:"保存"}),C.jsx("button",{style:yt,onClick:()=>i(null),children:"取消"})]})]})]})})}function Eg(){const[e,t]=z.useState([]),[n,r]=z.useState([]),[o,i]=z.useState(null),[l,s]=z.useState({fullName:"",enCode:"",description:""}),[a,u]=z.useState(""),[f,d]=z.useState([]);async function x(){t(await hp()),r(await vp())}z.useEffect(()=>{x()},[]);function m(c){s(c?{fullName:c.fullName,enCode:c.enCode||"",description:c.description||""}:{fullName:"",enCode:"",description:""}),i(c||{})}async function y(){if(!l.fullName)return alert("角色名必填");await cg({...l,id:o==null?void 0:o.id}),i(null),await x()}async function g(c){confirm("确认删除该角色?")&&(await fg(c),await x())}async function E(c){u(c);const h=await dg(c)||[];d(h)}async function p(){await yg(a,f),alert("授权已保存")}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{children:"角色管理"}),C.jsx("button",{style:be,onClick:()=>m(),children:"新增角色"}),C.jsxs("table",{style:Br,children:[C.jsx("thead",{children:C.jsxs("tr",{children:[C.jsx("th",{style:ie,children:"角色名"}),C.jsx("th",{style:ie,children:"编码"}),C.jsx("th",{style:ie,children:"操作"})]})}),C.jsx("tbody",{children:e.map(c=>C.jsxs("tr",{children:[C.jsx("td",{style:re,children:c.fullName}),C.jsx("td",{style:re,children:c.enCode}),C.jsxs("td",{style:re,children:[C.jsx("button",{style:yt,onClick:()=>m(c),children:"编辑"})," ",C.jsx("button",{style:yt,onClick:()=>E(c.id),children:"授权菜单"})," ",C.jsx("button",{style:wr,onClick:()=>g(c.id),children:"删除"})]})]},c.id))})]}),o&&C.jsxs("div",{style:{...ct,marginTop:16},children:[C.jsxs("h3",{children:[o.id?"编辑":"新增","角色"]}),C.jsxs("div",{style:{display:"flex",gap:8,flexWrap:"wrap"},children:[C.jsx("input",{style:de,placeholder:"角色名",value:l.fullName,onChange:c=>s({...l,fullName:c.target.value})}),C.jsx("input",{style:de,placeholder:"编码",value:l.enCode,onChange:c=>s({...l,enCode:c.target.value})}),C.jsx("input",{style:de,placeholder:"描述",value:l.description,onChange:c=>s({...l,description:c.target.value})})]}),C.jsxs("div",{style:{marginTop:12,display:"flex",gap:8},children:[C.jsx("button",{style:be,onClick:y,children:"保存"}),C.jsx("button",{style:yt,onClick:()=>i(null),children:"取消"})]})]}),a&&C.jsxs("div",{style:{...ct,marginTop:16},children:[C.jsxs("h3",{children:["角色菜单授权(",a,")"]}),C.jsx("div",{style:{display:"flex",flexDirection:"column",gap:6},children:n.map(c=>C.jsxs("label",{children:[C.jsx("input",{type:"checkbox",checked:f.includes(c.id),onChange:h=>d(v=>h.target.checked?[...v,c.id]:v.filter(w=>w!==c.id))})," ",c.fullName,C.jsxs("span",{style:{color:"#7a8794"},children:[" (",c.urlAddress,")"]})]},c.id))}),C.jsxs("div",{style:{marginTop:12,display:"flex",gap:8},children:[C.jsx("button",{style:be,onClick:p,children:"保存授权"}),C.jsx("button",{style:yt,onClick:()=>u(""),children:"关闭"})]})]})]})})}function Cg(){const[e,t]=z.useState([]),[n,r]=z.useState(null),[o,i]=z.useState({fullName:"",parentId:"0"});async function l(){t(await xg())}z.useEffect(()=>{l()},[]);const s=d=>{var x;return d==="0"?"(根)":((x=e.find(m=>m.id===d))==null?void 0:x.fullName)??d};function a(d){i(d?{fullName:d.fullName,parentId:d.parentId||"0"}:{fullName:"",parentId:"0"}),r(d||{})}async function u(){if(!o.fullName)return alert("机构名必填");await pg({...o,id:n==null?void 0:n.id}),r(null),await l()}async function f(d){if(confirm("确认删除该机构?")){try{await hg(d)}catch(x){return alert(x.message||"删除失败")}await l()}}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{children:"机构管理"}),C.jsx("button",{style:be,onClick:()=>a(),children:"新增机构"}),C.jsxs("table",{style:Br,children:[C.jsx("thead",{children:C.jsxs("tr",{children:[C.jsx("th",{style:ie,children:"名称"}),C.jsx("th",{style:ie,children:"上级"}),C.jsx("th",{style:ie,children:"操作"})]})}),C.jsx("tbody",{children:e.map(d=>C.jsxs("tr",{children:[C.jsx("td",{style:re,children:d.fullName}),C.jsx("td",{style:re,children:s(d.parentId)}),C.jsxs("td",{style:re,children:[C.jsx("button",{style:yt,onClick:()=>a(d),children:"编辑"})," ",C.jsx("button",{style:wr,onClick:()=>f(d.id),children:"删除"})]})]},d.id))})]}),n&&C.jsxs("div",{style:{...ct,marginTop:16},children:[C.jsxs("h3",{children:[n.id?"编辑":"新增","机构"]}),C.jsxs("div",{style:{display:"flex",gap:8},children:[C.jsx("input",{style:de,placeholder:"机构名",value:o.fullName,onChange:d=>i({...o,fullName:d.target.value})}),C.jsxs("select",{style:de,value:o.parentId,onChange:d=>i({...o,parentId:d.target.value}),children:[C.jsx("option",{value:"0",children:"(根)"}),e.filter(d=>d.id!==(n==null?void 0:n.id)).map(d=>C.jsx("option",{value:d.id,children:d.fullName},d.id))]})]}),C.jsxs("div",{style:{marginTop:12,display:"flex",gap:8},children:[C.jsx("button",{style:be,onClick:u,children:"保存"}),C.jsx("button",{style:yt,onClick:()=>r(null),children:"取消"})]})]})]})})}function wg(){const[e,t]=z.useState([]),[n,r]=z.useState(null),[o,i]=z.useState({fullName:"",urlAddress:"",parentId:"0",type:2,icon:"",sortCode:0});async function l(){t(await vp())}z.useEffect(()=>{l()},[]);const s=d=>{var x;return d==="0"?"(根)":((x=e.find(m=>m.id===d))==null?void 0:x.fullName)??d};function a(d){i(d?{fullName:d.fullName,urlAddress:d.urlAddress||"",parentId:d.parentId||"0",type:d.type??2,icon:d.icon||"",sortCode:d.sortCode??0}:{fullName:"",urlAddress:"",parentId:"0",type:2,icon:"",sortCode:0}),r(d||{})}async function u(){if(!o.fullName)return alert("菜单名必填");await vg({...o,id:n==null?void 0:n.id}),r(null),await l()}async function f(d){confirm("确认删除该菜单?")&&(await mg(d),await l())}return C.jsx("div",{style:Un,children:C.jsxs("div",{style:ct,children:[C.jsx("h2",{children:"菜单管理"}),C.jsx("button",{style:be,onClick:()=>a(),children:"新增菜单"}),C.jsxs("table",{style:Br,children:[C.jsx("thead",{children:C.jsxs("tr",{children:[C.jsx("th",{style:ie,children:"名称"}),C.jsx("th",{style:ie,children:"地址(key)"}),C.jsx("th",{style:ie,children:"上级"}),C.jsx("th",{style:ie,children:"排序"}),C.jsx("th",{style:ie,children:"操作"})]})}),C.jsx("tbody",{children:e.map(d=>C.jsxs("tr",{children:[C.jsx("td",{style:re,children:d.fullName}),C.jsx("td",{style:re,children:d.urlAddress}),C.jsx("td",{style:re,children:s(d.parentId)}),C.jsx("td",{style:re,children:d.sortCode}),C.jsxs("td",{style:re,children:[C.jsx("button",{style:yt,onClick:()=>a(d),children:"编辑"})," ",C.jsx("button",{style:wr,onClick:()=>f(d.id),children:"删除"})]})]},d.id))})]}),n&&C.jsxs("div",{style:{...ct,marginTop:16},children:[C.jsxs("h3",{children:[n.id?"编辑":"新增","菜单"]}),C.jsxs("div",{style:{display:"flex",gap:8,flexWrap:"wrap"},children:[C.jsx("input",{style:de,placeholder:"菜单名",value:o.fullName,onChange:d=>i({...o,fullName:d.target.value})}),C.jsx("input",{style:de,placeholder:"地址(key) 如 system/User",value:o.urlAddress,onChange:d=>i({...o,urlAddress:d.target.value})}),C.jsxs("select",{style:de,value:o.parentId,onChange:d=>i({...o,parentId:d.target.value}),children:[C.jsx("option",{value:"0",children:"(根)"}),e.filter(d=>d.id!==(n==null?void 0:n.id)).map(d=>C.jsx("option",{value:d.id,children:d.fullName},d.id))]}),C.jsxs("select",{style:de,value:o.type,onChange:d=>i({...o,type:+d.target.value}),children:[C.jsx("option",{value:1,children:"目录"}),C.jsx("option",{value:2,children:"页面"}),C.jsx("option",{value:3,children:"按钮"})]}),C.jsx("input",{style:de,placeholder:"图标",value:o.icon,onChange:d=>i({...o,icon:d.target.value})}),C.jsx("input",{style:de,type:"number",placeholder:"排序",value:o.sortCode,onChange:d=>i({...o,sortCode:+d.target.value})})]}),C.jsxs("div",{style:{marginTop:12,display:"flex",gap:8},children:[C.jsx("button",{style:be,onClick:u,children:"保存"}),C.jsx("button",{style:yt,onClick:()=>r(null),children:"取消"})]})]})]})})}function qt({children:e}){const t=fp(),n=_o();return t?e:C.jsx(Vv,{to:"/login",state:{from:n},replace:!0})}function Bg(){return C.jsxs(Qv,{children:[C.jsx(_t,{path:"/login",element:C.jsx($y,{})}),C.jsx(_t,{path:"/",element:C.jsx(qt,{children:C.jsx(Ky,{})})}),C.jsx(_t,{path:"/demo-item",element:C.jsx(qt,{children:C.jsx(Qy,{})})}),C.jsx(_t,{path:"/shop/Product",element:C.jsx(qt,{children:C.jsx(ng,{})})}),C.jsx(_t,{path:"/books/Book",element:C.jsx(qt,{children:C.jsx(lg,{})})}),C.jsx(_t,{path:"/system/User",element:C.jsx(qt,{children:C.jsx(gg,{})})}),C.jsx(_t,{path:"/system/Role",element:C.jsx(qt,{children:C.jsx(Eg,{})})}),C.jsx(_t,{path:"/system/Organize",element:C.jsx(qt,{children:C.jsx(Cg,{})})}),C.jsx(_t,{path:"/system/Module",element:C.jsx(qt,{children:C.jsx(wg,{})})})]})}gl.createRoot(document.getElementById("root")).render(C.jsx(mf.StrictMode,{children:C.jsx(Yv,{children:C.jsx(Bg,{})})})); diff --git a/src/frontend/dist/index.html b/src/frontend/dist/index.html new file mode 100644 index 0000000..ed7e88b --- /dev/null +++ b/src/frontend/dist/index.html @@ -0,0 +1,12 @@ + + + + + + SSW JNPF Lite · React MVP + + + +
+ +