平台包零业务:示例移到技能仓、解绑 example-packs、闸门全部改防回流

- 物理移出 packs/{asset,books,demo,shop}、modules/ 四个面 A 适配器、纯技能副本、
  纯业务测试 crud_it.rs 与 new-pack 脚手架(v0.3.0 tag 完整保留旧形态)。
- 删 example-packs feature / example_packs() / sspf-pack-* 依赖 / packs/* member;
  packs_gen.rs 与 modules/mod.rs 生成段降级为恒空的注入点,装配链一条不删;
  pack-sync.py 把「零包」钉成合法目标态。
- 尺子不再「跳过」:CP1 防回流清单、check-module 三条、AR2/PACK1 正向断言、
  AR17 升级为零业务依赖判据(含注入式反自证)、契约反自证换平台锚点、FACE 零包重算。
- 面 A 冒烟 43→21 条(17 条平台权限闭环 + 4 条业务端点 404);pack_smoke_it 改
  运行时防回流探针;auth/db/batch7/permission/seed/routes 单测换平台内置夹具。
- 契约 [MENU_TREE] 收成 5 条系统菜单、[RULER] 改 21/3;README/CLAUDE/HANDOFF/
  CHANGELOG/contract §5.1/schema.sql/db.rs 注释同步。

验收:cargo test --workspace --no-fail-fast 649 passed / 0 failed / 6 ignored;
verify.sh --smoke 14/14;check-arch 24/24 + 反自证 14/14;
cargo tree -p sspf 无 sspf-pack-*。前端 src/frontend 按要求保留。
This commit is contained in:
admin committed 2026-11-04 21:54:22 +08:00
1 parent ca8abf9cc9
commit ecb77b230f
94 files changed
+842 -8986

No files matched your search

+8 -31
View File
@@ -71,36 +71,13 @@ sspf-lowcode-exec = { path = "../../crates/sspf-lowcode-exec" }
# 业务包装载器(L2 静态:读清单 / 校验 / 收集声明)—— 不认识 axum
sspf-plugin = { path = "../../crates/sspf-plugin" }
# 🔴 业务包(只依赖 sspf-sdk)。
# 内核**只允许**依赖 packs/<app> 这类业务包,且**不得**在平台层(platform/)
# 出现 `use sspf_pack_*` ⇒ 业务知识不许漏进平台层(check-arch.sh 的 AR9 钉住)。
#
# ⚠️ 下面 `>>>GEN:PACK_DEPS` 段是**生成物**:`scripts/pack-sync.py` 按 `packs/*`
# 目录重写(crate 名取 `packs/<app>/Cargo.toml` 的 `[package].name`)。
# 加包请跑 `bash scripts/new-pack.sh <app> <Entity>`;手改会在下次同步被覆盖,
# 且 `scripts/verify.sh` 第一步(`pack-sync.py --check`)会直接红。
#
# 🔴 **全部 `optional = true`**(2026-11-04 标准平台包):默认 feature 下内核
# **不认识任何业务包** ⇒ 业务仓只依赖门面 `sspf` 时 `cargo tree` 里没有
# `sspf-pack-*`(`check-arch.sh` 的 AR17 钉住)。本仓的 `sspf-admin` /
# `sspf-tests` 显式开 `example-packs`。
# >>>GEN:PACK_DEPS
sspf-pack-asset = { path = "../../packs/asset", optional = true }
sspf-pack-books = { path = "../../packs/books", optional = true }
sspf-pack-demo = { path = "../../packs/demo", optional = true }
sspf-pack-shop = { path = "../../packs/shop", optional = true }
# <<<GEN:PACK_DEPS
# ---------------------------------------------------------------- features
#
# 🔴 **默认 feature = 空**:内核是**可被外部仓依赖的平台包**,不带任何示例业务。
# `example-packs` 只给两种消费者:本仓的 `sspf-admin`(默认装配)与
# `sspf-tests`(集成测试)—— 业务仓(如 tdc-rs)**不开**。
[features]
default = []
# ⚠️ 本段是**生成物**(`scripts/pack-sync.py` 按 `packs/*` 重写)。
# 用 `dep:` 语法聚合 ⇒ 不产生与依赖同名的隐式 feature(业务仓无法误开单个包)。
# >>>GEN:PACK_FEATURE
example-packs = ["dep:sspf-pack-asset", "dep:sspf-pack-books", "dep:sspf-pack-demo", "dep:sspf-pack-shop"]
# <<<GEN:PACK_FEATURE
# 🔴 **平台包零业务**(2026-11-04 清理):本 crate 没有 `[features]` 段,
# 也没有任何 `sspf-pack-*` 依赖。业务仓只依赖门面 `sspf`,通过
# `Platform::packs(reg)` / `.router()` / `.menus()` 注入自己的业务,
# **不开任何平台 feature**(`check-arch.sh` 的 AR17 钉住这条边界)。
#
# ⚠️ `>>>GEN:PACK_DEPS` 段仍是 `scripts/verify.sh` 第一步的判据:它必须**恒为空**。
# >>>GEN:PACK_DEPS
# <<<GEN:PACK_DEPS
+1 -1
View File
@@ -12,7 +12,7 @@
| 路径 | 是什么 | 加业务模块时 |
|---|---|---|
| `Cargo.toml` | lib 目标 + 依赖;末尾 `>>>GEN:PACK_DEPS` 段是 `pack-sync.py` 生成的 | 不手改(`new-pack.sh` 会写) |
| `Cargo.toml` | lib 目标 + 依赖;末尾 `>>>GEN:PACK_DEPS` 段由 `pack-sync.py` 生成、**恒空** | 不手改 |
| `src/routes.rs` | **唯一权威装配链**(面 A / 面 B 按判别头分流) | 不动 |
| `src/bootstrap.rs` | **装配根**:平台表 + 各包 DDL + 业务菜单注入种子 | 不动 |
| `src/compat.rs` | 契约面命名空间别名表(`compat::<域>::<handler>`,16 个域) | 不动 |
+9 -8
View File
@@ -863,13 +863,14 @@ CREATE TABLE base_data_set_relation (
);
-- ============================================================================
-- 🔴 **示例业务表已搬进业务包**(2026-11-04):
-- `demo_item` / `shop_product` / `book_shop_book` 的 DDL 现在住在
-- `packs/{demo,shop,books}/schema/001_init.sql`,由各包的 `include_str!`
-- 编译进二进制 ⇒ 内核启动时按包顺序幂等执行。
-- 🔴 **示例业务表已整体搬出本仓**(2026-11-04 零业务清理):
-- `demo_item` / `shop_product` / `book_shop_book` 的 DDL 现在住在**技能仓**
-- `ssw-jnpf-lite-rust` 的 `packs/{demo,shop,books}/schema/001_init.sql`,
-- 由各包的 `include_str!` 编译进二进制,经 `sspf::Platform::packs()` 注入。
-- 本仓 `schema.sql` 只有 177 张平台表,启动时不建任何业务表。
--
-- 为什么搬:这三个是**示例装配**(技能要带走当样板),示例的 DDL 就该跟着
-- 示例走 —— 否则「把 packs/demo 整目录搬去技能」这件事永远缺一块。
-- 为什么搬:这三个是**示例装配**,示例的 DDL 就该跟着示例走;平台仓零业务
-- ⇒ 谁把示例表写回本文件,CP1 / check-module / 运行时探针会立刻红。
--
-- 🔴 **对 react 版的影响**(「两版后端能开同一个库」这条约定):
-- 业务列名 / 列序 / 类型**逐字未变**;只是按平台规则补了
@@ -882,8 +883,8 @@ CREATE TABLE base_data_set_relation (
-- 🔴 **业务包的表不在本文件里**(批次 12 交付物 ③「DDL 跟着包走」)。
--
-- `asset_data_resource`(尚数网真实业务:数据资源)的建表语句现在住在
-- **`packs/asset/schema/001_init.sql`** ⇒ 由 `packs/asset/src/lib.rs` 用
-- `include_str!` **编译进二进制** ⇒ 内核启动时按包顺序幂等执行。
-- **技能仓** `ssw-jnpf-lite-rust` 的 `packs/asset/schema/001_init.sql`,
-- 由业务仓装载后经 `sspf::Platform::packs()` 注入 ⇒ 同一个 `Db` 上建表。
--
-- 理由:加一张业务表不该改内核的 `schema.sql`(那是**平台层**的数据模型)
-- ⇒ 业务表的 DDL 跟着**业务包**走 ⇒ 包目录能整目录搬走 ⇒ 单二进制部署。
+4 -21
View File
@@ -6,7 +6,7 @@
//! 业务仓(tdc-rs)零成本拿到同一把尺子 ⇒ 不需要抄 123 张表的名字。
//!
//! 🔴 本模块**不读业务清单**:spec 与包 DDL 由调用方传进来
//! (本仓 = `bootstrap::packs()` + `modules::all_specs()`;外部 = 门面注入)。
//! (本仓 = 恒空的 `bootstrap::packs()` + `modules::all_specs()`;外部 = 门面注入)。
use std::path::{Path, PathBuf};
@@ -20,7 +20,7 @@ use sspf_plugin::PackDdl;
///
/// 🔴 **只列 `base_*`**:业务表名是**业务知识** ⇒ 写死在这里 ⇒
/// 加一个业务模块要改入口文件 ⇒ 违反红线 12(「加一个业务模块只碰业务层」)。
/// 业务表由 `modules::all_specs()` 派生,并与 `db/schema.sql` **对账**
/// 业务表由调用方注入的 spec / 包 DDL 派生,并与 `db/schema.sql` **对账**
/// (见 [`whitelist_self_check`])⇒ 拼错 / 漏建 / 孤儿 DDL 三种错都抓得到。
///
/// 多应用 MVP 新增了平台表 `base_system`(`SystemEntity` 注册表,
@@ -325,7 +325,7 @@ pub fn whitelist_self_check(specs: &[EntitySpec], pack_ddls: &[PackDdl]) -> Resu
/// 本仓默认形态:spec 从业务层取、包表从 [`crate::bootstrap::packs`] 取。
///
/// 🔴 默认 feature 下两者都为空(平台包不带业务)⇒ 只校验平台表与 `schema.sql` 对账。
/// 🔴 平台包零业务 ⇒ 两者恒空 ⇒ 只校验平台表与 `schema.sql` 对账。
pub fn whitelist_self_check_platform() -> Result<(), String> {
let reg = crate::bootstrap::packs().map_err(|e| format!("业务包装载失败: {e}"))?;
whitelist_self_check(crate::modules::all_specs(), &reg.ddls)
@@ -468,27 +468,10 @@ mod tests {
/// `crates/sspf-admin` 搬来 —— 那里只剩 CLI,没有再校验表清单的资格)。
///
/// 加业务表却忘了加 DDL(或反过来留了孤儿 DDL)⇒ 这里红,而不是等启动时
/// `exit 1`。🔴 默认 feature 下 spec / 包 DDL 都是空的 ⇒ 只校验平台表那半,
/// `exit 1`。🔴 平台包零业务 ⇒ spec / 包 DDL 恒空 ⇒ 只校验平台表那半,
/// 仍然有防错价值(`schema.sql` 里多一张没人认领的表也算孤儿)。
#[test]
fn whitelist_self_check_passes_for_this_repo() {
whitelist_self_check_platform().expect("本仓的表清单与 db/schema.sql 必须对得上");
}
/// 🔴 `BASE_TABLES` 里只许有平台表:业务表名进来 ⇒ 加业务模块要改内核
/// (红线 12:加一个业务模块只碰业务层)。
///
/// 🔴 只在 `example-packs` 下有意义(否则 spec 清单为空 ⇒ 断言天然成立 = 假闸门)。
#[cfg(feature = "example-packs")]
#[test]
fn base_tables_carry_no_business_table() {
let base: Vec<&str> = BASE_TABLES.to_vec();
for spec in crate::modules::all_specs() {
assert!(
!base.contains(&spec.table),
"BASE_TABLES 里不许出现业务表 {}",
spec.table
);
}
}
}
+12 -144
View File
@@ -18,7 +18,7 @@
//! 🔴 **「加一个业务包」的完整动作**(批次 12.5 之后):
//!
//! ```bash
//! bash scripts/new-pack.sh <app> <Entity> --name "中文名" --columns "a:VARCHAR(200)"
//! 🔴 本仓零业务:包清单恒空;业务仓用 `sspf::Platform::packs(reg)` 注入。
//! ```
//!
//! ⇒ 一条命令生成 `packs/<app>/`(真源)+ `modules/<app>.rs`(面 A 适配器),
@@ -237,153 +237,21 @@ pub fn version() -> &'static str {
}
#[cfg(test)]
mod feature_tests {
/// 🔴 **装载器必须跟着 feature 走**(2026-11-04 标准平台包)。
///
/// 🔴 不带 `cfg` 的原因同 `modules::feature_tests`:下面那组「4 个包都装得上」
/// 的断言只在 `example-packs` 下编译 ⇒ 这里兜住「两组都没跑」的静默退化。
#[test]
fn registry_follows_the_example_packs_feature() {
let reg = super::load_packs().expect("默认/示例 feature 都必须是可装载的形态");
if cfg!(feature = "example-packs") {
assert!(!reg.entities.is_empty(), "开了 example-packs ⇒ 至少要装上一个包");
} else {
assert!(
reg.entities.is_empty() && reg.ddls.is_empty(),
"默认 feature 是平台包:不得装载任何示例业务包"
);
}
}
}
#[cfg(all(test, feature = "example-packs"))]
mod tests {
use super::*;
use sspf_contract::route::HttpMethod;
/// 🔴 **业务包必须能装载**(批次 12 的核心验证物)。
///
/// 一旦包装载不过 ⇒ 「放个目录进 `packs/`」这个承诺就是假的。
///
/// 🔴 **不写死条数**(批次 12.5):条数由 `packs/*` 的目录数决定,
/// 写死会让「加一个包」变成「先改测试」⇒ 假闸门。
/// 改成**结构性断言**:每个实体都要有 DDL、有菜单、有 3 条路由。
/// 🔴 **平台包恒零业务**(2026-11-04 清理):`load_packs()` 必须返回空注册表。
/// 业务仓通过 `sspf::Platform::packs(reg)` 注入,本仓一次都不读这个单例来装业务。
#[test]
fn every_pack_loads_with_entities_menus_routes_and_ddls() {
let reg = load_packs().expect("全部业务包必须装载成功");
assert!(!reg.entities.is_empty(), "至少要装上一个包");
assert!(!reg.manifests.is_empty(), "包清单不能为空(否则卸载/导出都无从下手)");
for spec in &reg.entities {
assert!(
reg.ddls.iter().any(|d| d.table == spec.table),
"实体 {} 的表 {} 没有对应 DDL(表建不出来)",
spec.entity,
spec.table
);
if let Some(key) = spec.module_key {
assert!(
reg.menus.iter().any(|m| m.url_address == key),
"实体 {} 的 module_key={} 没有对应菜单 ⇒ 守卫查不到菜单 ⇒ 静默放行",
spec.entity,
key
);
}
}
// 每个实体恰好 3 条路由(List / Save / Delete)。
assert_eq!(
reg.routes.len(),
reg.entities.len() * 3,
"每条实体应有 3 条路由(漏一条 ⇒ 某个动作静默 404)"
);
// 🔴 asset 是基准包:它的存在性是真断言,不是计数。
assert!(
reg.ddls.iter().any(|d| d.table == "asset_data_resource"),
"asset 包必须在(基准包)"
);
fn default_registry_is_empty() {
let reg = super::load_packs().expect("空注册表是合法形态");
assert!(reg.entities.is_empty(), "平台包不得装载业务实体");
assert!(reg.ddls.is_empty(), "平台包不得携带业务 DDL");
assert!(reg.menus.is_empty(), "平台包不得携带业务菜单");
assert!(reg.routes.is_empty(), "平台包不得携带业务路由");
}
/// 🔴 **包声明的路由必须是官方形状**(面 B),且方法与动作对应。
/// `pack_router(空注册表)` 不注册任何端点(平台能力仍在,只是没有内容)。
#[test]
fn pack_routes_are_official_shape() {
let reg = load_packs().expect("asset 包必须装载成功");
for r in &reg.routes {
assert!(r.path.starts_with("/api/"), "必须是官方形状: {}", r.path);
assert!(
!r.path.starts_with("/api/ssw/"),
"不许用面 A 的 /api/ssw/...: {}",
r.path
);
}
let list = reg
.routes
.iter()
.find(|r| r.method == HttpMethod::Get)
.expect("必须有 GET 路由");
// 🔴 按**路径存在性**断言,不假设「第一条就是 asset」(包的装载顺序会变)。
assert!(
reg.routes.iter().any(|r| r.path == "/api/asset/DataResource"),
"asset 的列表路由必须在(基准包);实际首条 GET 是 {}",
list.path
);
}
/// 🔴 **包的路由必须是官方 RESTful 形状**(不是「官方前缀 + ssw 动作后缀」)。
///
/// 🔴 实测官方源码(`jnpf-java-boot` 全部 controller):
/// `/xxx/List` GET 52 + POST 21(碰巧存在)、`/xxx/Save` **仅 4 条**
/// (低代码/打印/AI 特例)、`/xxx/Delete` **0 条**(不存在)。
/// ⇒ CRUD 通用形状是 RESTful ⇒ 用后缀 = 集成时必然改路径。
#[test]
fn pack_routes_use_official_restful_shape() {
let reg = load_packs().expect("asset 包必须装载成功");
for r in &reg.routes {
assert!(
!r.path.ends_with("/Save"),
"官方没有 /Save CRUD 端点: {}",
r.path
);
assert!(
!r.path.ends_with("/Delete"),
"官方没有 /Delete 端点: {}",
r.path
);
}
let del = reg
.routes
.iter()
.find(|r| r.method == HttpMethod::Delete)
.expect("必须有删除路由");
assert!(del.path.contains("{id}"), "删除路由必须带 {{id}}: {}", del.path);
}
/// 🔴 **包路由生成的 axum 路由条数 = 声明条数** —— 少一条就是漏注册。
#[test]
fn pack_router_registers_all_declared_routes() {
let reg = load_packs().expect("全部业务包必须装载成功");
// 🔴 生成路由不 panic = 路径合法(axum 遇到非法路径会 panic)。
let _router = pack_router(&reg);
// 🔴 不写死 3:路由条数跟着包走(每条实体 3 条)。
assert_eq!(reg.routes.len(), reg.entities.len() * 3);
}
/// 🔴 **包的 DDL 必须含 `f_tenant_id`** —— 官方 `base_*` 表全部带它,
/// 参与复合主键 `(f_id, f_tenant_id)` ⇒ 缺这列导不进官方。
#[test]
fn pack_ddls_carry_tenant_id_and_composite_key() {
let reg = load_packs().expect("全部业务包必须装载成功");
for ddl in &reg.ddls {
assert!(
ddl.sql.contains("f_tenant_id"),
"{} 的 DDL 缺 f_tenant_id(集成时导不进官方)",
ddl.table
);
assert!(
ddl.sql.contains("PRIMARY KEY (f_id, f_tenant_id)"),
"{} 的主键必须是 (f_id, f_tenant_id)",
ddl.table
);
}
fn pack_router_of_empty_registry_is_empty() {
let _ = super::pack_router(&sspf_plugin::PackRegistry::default());
}
}
+9 -8
View File
@@ -13,9 +13,9 @@
//! | **`bootstrap.rs`** | 装配根:平台表 + 各包 DDL + 业务菜单注入种子(**唯一同时认识平台层与业务层的地方**) | — | 不动 |
//! | **`compat.rs`** | 契约面**命名空间别名表**:`compat::<域>::<handler>` 共 16 个域 | `crates/sspf-compat-*` | 不动 |
//! | **`forward.rs`** | **6 个转发壳**(低代码 4 + MCP 2),只有 `pub use` | `crates/sspf-lowcode-exec`、`crates/sspf-mcp-adapter` | 不动 |
//! | **`packs_gen.rs`** | ⚠️ **生成物**:业务包注册表 + `pack.toml` 快照 | `scripts/pack-sync.py` 读 `packs/*` | **不手改**;改完 `packs/` 跑脚本 |
//! | **`packs_gen.rs`** | ⚠️ **生成物**:恒空的业务包注册表(平台注入点) | `scripts/pack-sync.py` | **不手改** |
//! | **`test_support.rs`** | 内核**单测**共享的进程级 pglite(`#[cfg(test)]`,仅 `routes.rs` 的单测用) | — | 不动 |
//! | **`modules/`** | **业务层**(面 A):spec + 菜单 + 路由汇总 | 4 个模块文件都是「面 A 适配器 + `pub use` 转发」→ `packs/{asset,demo,shop,books}` | ✅ **只动这里** |
//! | **`modules/`** | **业务装配点**(面 A):恒空的 spec / 菜单 / 路由汇总 | 生成物;业务由外部经门面注入 | 不动 |
//!
//! ## 三条边界(`scripts/check-arch.sh` 钉住,踩线即红)
//!
@@ -34,13 +34,14 @@
//! | 集成测试(37 个 `*_it.rs`) | `crates/tests/tests/` |
//! | 平台核心(信封 / 登录 / 权限 / CRUD 引擎 / cipher) | `crates/sspf-core` |
//! | 面 B 各域实现(system / permission / msg / workflow / ext / onlinedev) | `crates/sspf-compat-*` |
//! | 业务包真源 | `packs/<app>`;内核侧 `modules/<app>.rs` 只是「面 A 适配器 + `pub use` 转发」 |
//! | 业务包真源 | **业务仓**(本仓零业务);技能仓 `ssw-jnpf-lite-rust` 有 4 个示例包 |
//!
//! ## 业务层当前长什么样(2026-11-04)
//! ## 平台包零业务(2026-11-04 清理)
//!
//! `packs/` 下 4 个包:`asset`(真实业务:数据资源)+ `demo` / `shop` / `books`
//! (**示例包**,技能要带走当样板)。内核的 `modules/*.rs` 里**没有任何 spec**
//! (`check-arch.sh` 的 PACK1 钉住)—— 加业务模块跑 `bash scripts/new-pack.sh`。
//! `packs/{asset,books,demo,shop}` 与 `modules/*.rs` 的 4 个面 A 适配器已整体搬到
//! 技能仓 `ssw-jnpf-lite-rust`(`v0.3.0` tag 完整保留旧形态)。本仓只留**注入点**:
//! `sspf::Platform::packs(reg)` / `.router()` / `.menus()` / `.ddl()`。
//! ⇒ `cargo tree -p sspf` 里没有 `sspf-pack-*`,`/api/health` 是 177 张平台表。
pub mod bootstrap;
/// 🔴 **进程级启动原语**(定位项目根 / 白名单自检 / 开库 / 优雅停机)。
@@ -59,7 +60,7 @@ pub use forward::{
pub mod modules;
/// 🔴 **本文件是 `scripts/pack-sync.py` 生成的**(业务包清单 + `pack.toml` 快照)
/// ⇒ 不要手改;加包跑 `bash scripts/new-pack.sh`。
/// ⇒ 不要手改;本仓零业务,业务包由业务仓经 `sspf::Platform::packs()` 注入。
pub mod packs_gen;
pub mod routes;
/// 内核**单测**共享的 pglite 实例(`routes.rs` 的 `#[cfg(test)]` 用)。
-88
View File
@@ -1,88 +0,0 @@
//! 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_core::crud::{handle_delete, handle_list, handle_save};
use sspf_core::envelope::ActionResult;
use sspf_core::state::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<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
handle_list(&state, &headers, &DATA_RESOURCE_SPEC).await
}
/// `POST /api/ssw/asset/DataResource/Save`。
pub async fn data_resource_save(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
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<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
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<AppState> {
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),
)
}
-75
View File
@@ -1,75 +0,0 @@
//! books —— 业务模块:Book(物理表 `book_shop_book`)。
//!
//! 🔴 **本文件是「面 A 适配器 + spec 的转发点」,不是 spec 的家**:
//! 真源在 `packs/books/src/lib.rs`(业务包,**只依赖 sspf-sdk**),
//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**(`check-arch.sh` 的 PACK1 钉住)。
//!
//! 🔴 **面 A 与面 B 各住一处**:
//! - **本文件 = 面 A**(`/api/ssw/books/Book/…`)—— 本仓自造的 ssw 约定,
//! 留给 Rust 终端场景,**一个字都不改**(前端在用它);
//! - **业务包 = 面 B**(`/api/books/Book`)—— 官方 JNPF 形状,
//! 集成到官方 Java 时能直接搬。
//!
//! 🔴 **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};
use axum::http::HeaderMap;
use axum::routing::{delete, get, post};
use axum::{Json, Router};
use sspf_core::crud::{handle_delete, handle_list, handle_save};
use sspf_core::envelope::ActionResult;
use sspf_core::state::AppState;
// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。
pub use sspf_pack_books::BOOK_MENU;
pub use sspf_pack_books::BOOK_SPEC;
/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。
///
/// 🔴 路径写字面量(不用下标):`scripts/check-contract-scan.py` 是静态解析,
/// 认不出数组下标 ⇒ 写下标会让契约闸门判「登记了、代码里没有」。
pub const ROUTES: [&str; 3] = [
"/api/ssw/books/Book/List",
"/api/ssw/books/Book/Save",
"/api/ssw/books/Book/Delete",
];
/// `GET /api/ssw/books/Book/List`。
pub async fn book_list(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
handle_list(&state, &headers, &BOOK_SPEC).await
}
/// `POST /api/ssw/books/Book/Save`。
pub async fn book_save(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
handle_save(&state, &headers, &BOOK_SPEC, &body).await
}
/// `DELETE /api/ssw/books/Book/Delete?id=`。
pub async fn book_delete(
State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
handle_delete(&state, &headers, &BOOK_SPEC, &raw).await
}
/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。
pub fn router() -> Router<AppState> {
Router::new()
.route("/api/ssw/books/Book/List", get(book_list))
.route("/api/ssw/books/Book/Save", post(book_save))
.route("/api/ssw/books/Book/Delete", delete(book_delete))
}
-75
View File
@@ -1,75 +0,0 @@
//! demo —— 业务模块:DemoItem(物理表 `demo_item`)。
//!
//! 🔴 **本文件是「面 A 适配器 + spec 的转发点」,不是 spec 的家**:
//! 真源在 `packs/demo/src/lib.rs`(业务包,**只依赖 sspf-sdk**),
//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**(`check-arch.sh` 的 PACK1 钉住)。
//!
//! 🔴 **面 A 与面 B 各住一处**:
//! - **本文件 = 面 A**(`/api/ssw/demo/DemoItem/…`)—— 本仓自造的 ssw 约定,
//! 留给 Rust 终端场景,**一个字都不改**(前端在用它);
//! - **业务包 = 面 B**(`/api/demo/DemoItem`)—— 官方 JNPF 形状,
//! 集成到官方 Java 时能直接搬。
//!
//! 🔴 **DDL 跟着包走**:`demo_item` 的建表语句在 `packs/demo/schema/001_init.sql`,
//! 编译进二进制 ⇒ 不再手抄进 `db/schema.sql`。
//!
//! 🔴 **本包是示例包**:`packs/demo` 整目录可搬去技能当样板,本文件是它在本仓的
//! 面 A 适配器(技能带走示例时,这份适配器可以不要)。
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_core::crud::{handle_delete, handle_list, handle_save};
use sspf_core::envelope::ActionResult;
use sspf_core::state::AppState;
// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。
pub use sspf_pack_demo::DEMO_MENU;
pub use sspf_pack_demo::DEMO_SPEC;
/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。
///
/// 🔴 路径写字面量(不用下标):`scripts/check-contract-scan.py` 是静态解析,
/// 认不出数组下标 ⇒ 写下标会让契约闸门判「登记了、代码里没有」。
pub const ROUTES: [&str; 3] = [
"/api/ssw/demo/DemoItem/List",
"/api/ssw/demo/DemoItem/Save",
"/api/ssw/demo/DemoItem/Delete",
];
/// `GET /api/ssw/demo/DemoItem/List`。
pub async fn demo_item_list(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
handle_list(&state, &headers, &DEMO_SPEC).await
}
/// `POST /api/ssw/demo/DemoItem/Save`。
pub async fn demo_item_save(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
handle_save(&state, &headers, &DEMO_SPEC, &body).await
}
/// `DELETE /api/ssw/demo/DemoItem/Delete?id=`。
pub async fn demo_item_delete(
State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
handle_delete(&state, &headers, &DEMO_SPEC, &raw).await
}
/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。
pub fn router() -> Router<AppState> {
Router::new()
.route("/api/ssw/demo/DemoItem/List", get(demo_item_list))
.route("/api/ssw/demo/DemoItem/Save", post(demo_item_save))
.route("/api/ssw/demo/DemoItem/Delete", delete(demo_item_delete))
}
+19 -349
View File
@@ -3,7 +3,7 @@
//! 🔴 **加一个业务模块只碰本目录,而且不用手改本文件**(批次 12.5):
//!
//! ```bash
//! bash scripts/new-pack.sh <app> <Entity> --name "中文名" --columns "a:VARCHAR(200)"
//! 🔴 本仓零业务:五个生成段恒空;业务路由由业务仓经门面注入。
//! ```
//!
//! 它会建 `packs/<app>/`(真源)+ 本目录的 `<app>.rs`(面 A 适配器),
@@ -31,70 +31,22 @@ use sspf_core::menu::MenuSpec;
use sspf_core::state::AppState;
// >>>GEN:MODS
// 每个模块一行:**文件即登记**(顺序 = 文件名字典序,不代表业务顺序)。
// 🔴 只在 `example-packs` 下编译 —— 默认 feature 的内核**不认识任何业务模块**。
#[cfg(feature = "example-packs")]
pub mod asset;
#[cfg(feature = "example-packs")]
pub mod books;
#[cfg(feature = "example-packs")]
pub mod demo;
#[cfg(feature = "example-packs")]
pub mod shop;
// 🔴 **平台包零业务**:本仓不认识任何业务模块。
// 业务模块的路由由业务仓经 `sspf::Platform::router()` 注入。
// <<<GEN:MODS
// >>>GEN:SPECS
/// 全部业务实体 spec。
///
/// 🔴 **本段由 `scripts/pack-sync.py` 生成** —— 加模块不用手改(见文件头)。
#[cfg(feature = "example-packs")]
pub const ALL_SPECS: &[EntitySpec] = &[
asset::DATA_RESOURCE_SPEC,
books::BOOK_SPEC,
demo::DEMO_SPEC,
shop::PRODUCT_SPEC,
];
/// 默认 feature:平台侧零业务 ⇒ 空清单(业务仓用 `sspf::Platform::packs` 注入)。
#[cfg(not(feature = "example-packs"))]
/// 本仓业务实体 spec:恒为空(平台包零业务)。
pub const ALL_SPECS: &[EntitySpec] = &[];
// <<<GEN:SPECS
// >>>GEN:ROUTES
/// **全部业务路由**(面 A:`/api/ssw/{appCode}/{Entity}/{动作}`,每模块 3 条)。
///
/// 🔴 **与 `ALL_SPECS` 同序**(同一份模块清单生成)⇒ 可以按 3 条一组配对。
#[cfg(feature = "example-packs")]
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],
];
/// 默认 feature:没有业务路由可登记。
#[cfg(not(feature = "example-packs"))]
/// 本仓业务路由表:恒为空(平台包零业务)。
pub const ALL_ROUTES: &[&str] = &[];
// <<<GEN:ROUTES
// >>>GEN:MENUS
/// 全部业务内置菜单(由**装配根** [`crate::bootstrap`] 传给平台层的种子
/// ⇒ **平台层不认任何业务菜单**,红线 12)。
#[cfg(feature = "example-packs")]
pub const ALL_MENUS: &[MenuSpec] = &[
asset::DATA_RESOURCE_MENU,
books::BOOK_MENU,
demo::DEMO_MENU,
shop::PRODUCT_MENU,
];
/// 默认 feature:平台侧零业务 ⇒ 种子只种平台菜单。
#[cfg(not(feature = "example-packs"))]
/// 本仓业务内置菜单:恒为空;业务菜单由 `.menus()` / `.packs()` 注入。
pub const ALL_MENUS: &[MenuSpec] = &[];
// <<<GEN:MENUS
@@ -117,314 +69,32 @@ pub fn find_spec(app_code: &str, entity: &str) -> Option<&'static EntitySpec> {
}
// >>>GEN:ROUTER
/// **全部业务模块的路由**(`Router::merge` 进总路由)。
///
/// 🔴 加业务模块 ⇒ **不用改这里**(本段由 `pack-sync.py` 生成)。
#[cfg(feature = "example-packs")]
pub fn router() -> Router<AppState> {
asset::router()
.merge(books::router())
.merge(demo::router())
.merge(shop::router())
}
/// 默认 feature:没有任何业务路由。
#[cfg(not(feature = "example-packs"))]
/// 本仓业务路由:恒为空。
pub fn router() -> Router<AppState> {
Router::new()
}
// <<<GEN:ROUTER
#[cfg(test)]
mod feature_tests {
use super::*;
/// 🔴 **本模块的清单必须跟着 feature 走**(2026-11-04 标准平台包)。
///
/// 🔴 **为什么这条测试不带 `cfg`**:它是「尺子会不会变瞎」的探针。
/// 下面那组基准模块断言只在 `example-packs` 下编译
/// (默认 feature 时清单是空的,断言必然假红);
/// 如果**两组都没编译**,这里能立刻看出来 —— 而不是「测试数悄悄变少」。
///
/// 🔴 跑法:`cargo test --workspace`(`sspf-tests` 会开 feature ⇒ 全组都跑)。
/// `cargo test -p ssw-platform` 单独跑只跑本条(默认 feature)。
#[test]
fn spec_and_menu_lists_follow_the_feature() {
if cfg!(feature = "example-packs") {
assert!(
all_specs().len() >= 4,
"开了 example-packs ⇒ 至少要保住 demo/shop/books/asset 四个模块"
);
assert!(
!all_menus().is_empty(),
"开了 example-packs ⇒ 业务菜单不能是空的(否则面 B 点权限全 403)"
);
assert!(
!ALL_ROUTES.is_empty(),
"开了 example-packs ⇒ 业务路由不能是空的"
);
} else {
assert!(
all_specs().is_empty() && all_menus().is_empty() && ALL_ROUTES.is_empty(),
"默认 feature 是**平台包**:不得携带任何业务 spec / 菜单 / 路由"
);
}
}
}
#[cfg(all(test, feature = "example-packs"))]
mod tests {
use super::*;
use sspf_core::db;
/// spec 表里 app_code + entity 唯一,且四个基准模块都在。
/// 🔴 **平台包恒零业务**(2026-11-04 清理):示例模块已搬到技能仓,
/// 本仓的 spec / 菜单 / 路由清单**必须全空**。任何一项非空 ⇒ 业务回流。
///
/// 🔴 **不写死条数**(批次 12.5):条数由 `modules/*.rs` 文件数决定,
/// 加一个模块就 +1 ⇒ 写死会变成「加模块必须先改测试」的假闸门。
/// 🔴 这条是「尺子会不会变瞎」的探针:不带 `cfg` ⇒ 任何构建都会跑,
/// 不会出现「测试数悄悄变少」而没人发现。
#[test]
fn all_specs_are_unique_and_complete() {
let specs = all_specs();
assert!(specs.len() >= 4, "至少要保住 demo/shop/books/asset 四个模块");
for (i, s) in specs.iter().enumerate() {
for other in &specs[i + 1..] {
assert!(
!(s.app_code == other.app_code && s.entity == other.entity),
"app_code + entity 必须唯一: {} / {}",
s.app_code,
s.entity
);
}
}
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());
fn platform_carries_no_business_modules() {
assert!(all_specs().is_empty(), "平台包不得携带业务 spec");
assert!(all_menus().is_empty(), "平台包不得携带业务菜单");
assert!(ALL_ROUTES.is_empty(), "平台包不得携带业务路由");
assert!(find_spec("demo", "DemoItem").is_none(), "平台包不认任何业务实体");
}
/// 🔴 每列的 `json_key` 必须等于 `db::column_to_json_key(column)`
/// (`f_title` ⇒ `title`)—— 不一致 ⇒ 投影别名与 body 键会对不上,且**静默**。
/// 业务路由恒为空 ⇒ `router()` 不注册任何端点。
#[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 的四张基准表列清单(**逐字**):列名与列序。
///
/// 🔴 **按 (app, entity) 查找,不按数组下标 zip** —— 生成段的顺序随
/// `modules/*.rs` 文件名变化 ⇒ 用下标取值是「顺序一变就假失败」。
#[test]
fn column_sets_match_contract_5_3() {
let names = |app: &str, ent: &str| -> Vec<&str> {
find_spec(app, ent)
.expect("基准模块必须在")
.columns
.iter()
.map(|c| c.column)
.collect()
};
assert_eq!(
names("demo", "DemoItem"),
vec![
"f_id",
"f_title",
"f_status",
"f_creator_user_id",
"f_creator_time",
"f_delete_mark"
]
);
assert_eq!(
names("shop", "Product"),
vec![
"f_id",
"f_title",
"f_price",
"f_creator_user_id",
"f_creator_time",
"f_delete_mark"
]
);
assert_eq!(
names("books", "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"
]
);
// 🔴 asset:列序**逐字对齐公司本体 `DataResource`**(数据资源),
// 末尾多一列 `f_tenant_id` —— 官方 `base_*` 表全部带它
// (`DEFAULT '0' NOT NULL`,参与复合主键 `(f_id, f_tenant_id)`)
// ⇒ **单租户也不许省**(集成时缺这一列 ⇒ 导不进官方)。
assert_eq!(
names("asset", "DataResource"),
vec![
"f_id",
"f_name",
"f_category",
"f_scenario",
"f_provider",
"f_format",
"f_scale",
"f_source",
"f_register_time",
"f_creator_user_id",
"f_creator_time",
"f_delete_mark",
"f_tenant_id"
]
);
}
/// 守卫 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")
);
assert_eq!(
find_spec("asset", "DataResource").unwrap().module_key,
Some("asset/DataResource")
);
}
/// 表名必须过白名单(拼进 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);
assert_eq!(
find_spec("asset", "DataResource").unwrap().creator_fixed,
None
);
}
/// 🔴 **业务路由的形状钉死** —— 每条必须是 `/api/ssw/{app_code}/{entity}/{List|Save|Delete}`。
///
/// 🔴 **`ALL_ROUTES` 与 `ALL_SPECS` 同序**(两段都由 `pack-sync.py` 按同一份
/// 模块清单生成)⇒ 可以按 3 条一组配对。这个「同序」由本测试兜住:
/// 一旦有人手改生成段导致错位,下面的路径断言立刻红。
#[test]
fn business_routes_follow_the_contract_shape() {
assert_eq!(
ALL_ROUTES.len(),
ALL_SPECS.len() * 3,
"每个模块 3 条路由;ALL_ROUTES 与 ALL_SPECS 必须同序(生成段不许手改)"
);
for (spec, routes) in ALL_SPECS.iter().zip(ALL_ROUTES.chunks(3)) {
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`
/// ③ 前端 `<Route path="…">` —— 任一不一致 ⇒ 菜单显示了但守卫不命中
/// (或反过来)⇒ **静默**失败。
///
/// 🔴 **按 `url_address` 查找,不按数组下标配对** —— 菜单与 spec 是两份声明,
/// 用下标配对相当于假设「每个模块恰好 1 个实体 + 1 个菜单」。
#[test]
fn every_spec_with_module_key_has_a_matching_menu() {
for spec in all_specs() {
let Some(key) = spec.module_key else {
continue; // 仅需登录的模块(demo)没有菜单守卫
};
let menu = all_menus()
.iter()
.find(|m| m.url_address == key)
.unwrap_or_else(|| {
panic!(
"{} 的 module_key 是 {},但没有菜单的 url_address 等于它",
spec.entity, key
)
});
assert!(
!menu.en_code.trim().is_empty(),
"菜单 {} 的 f_en_code 不能为空(面 B 的点权限判据靠它)",
menu.id
);
}
}
/// 🔴 **菜单 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
);
}
}
fn router_is_empty() {
let _: Router<AppState> = router();
}
}
-75
View File
@@ -1,75 +0,0 @@
//! shop —— 业务模块:Product(物理表 `shop_product`)。
//!
//! 🔴 **本文件是「面 A 适配器 + spec 的转发点」,不是 spec 的家**:
//! 真源在 `packs/shop/src/lib.rs`(业务包,**只依赖 sspf-sdk**),
//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**(`check-arch.sh` 的 PACK1 钉住)。
//!
//! 🔴 **面 A 与面 B 各住一处**:
//! - **本文件 = 面 A**(`/api/ssw/shop/Product/…`)—— 本仓自造的 ssw 约定,
//! 留给 Rust 终端场景,**一个字都不改**(前端在用它);
//! - **业务包 = 面 B**(`/api/shop/Product`)—— 官方 JNPF 形状,
//! 集成到官方 Java 时能直接搬。
//!
//! 🔴 **DDL 跟着包走**:`shop_product` 的建表语句在 `packs/shop/schema/001_init.sql`,
//! 编译进二进制 ⇒ 不再手抄进 `db/schema.sql`。
//!
//! 🔴 **本包是示例包**:`packs/shop` 整目录可搬去技能当样板,本文件是它在本仓的
//! 面 A 适配器(技能带走示例时,这份适配器可以不要)。
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_core::crud::{handle_delete, handle_list, handle_save};
use sspf_core::envelope::ActionResult;
use sspf_core::state::AppState;
// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。
pub use sspf_pack_shop::PRODUCT_MENU;
pub use sspf_pack_shop::PRODUCT_SPEC;
/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。
///
/// 🔴 路径写字面量(不用下标):`scripts/check-contract-scan.py` 是静态解析,
/// 认不出数组下标 ⇒ 写下标会让契约闸门判「登记了、代码里没有」。
pub const ROUTES: [&str; 3] = [
"/api/ssw/shop/Product/List",
"/api/ssw/shop/Product/Save",
"/api/ssw/shop/Product/Delete",
];
/// `GET /api/ssw/shop/Product/List`。
pub async fn product_list(
State(state): State<AppState>,
headers: HeaderMap,
) -> Json<ActionResult> {
handle_list(&state, &headers, &PRODUCT_SPEC).await
}
/// `POST /api/ssw/shop/Product/Save`。
pub async fn product_save(
State(state): State<AppState>,
headers: HeaderMap,
body: Bytes,
) -> Json<ActionResult> {
handle_save(&state, &headers, &PRODUCT_SPEC, &body).await
}
/// `DELETE /api/ssw/shop/Product/Delete?id=`。
pub async fn product_delete(
State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery,
) -> Json<ActionResult> {
handle_delete(&state, &headers, &PRODUCT_SPEC, &raw).await
}
/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。
pub fn router() -> Router<AppState> {
Router::new()
.route("/api/ssw/shop/Product/List", get(product_list))
.route("/api/ssw/shop/Product/Save", post(product_save))
.route("/api/ssw/shop/Product/Delete", delete(product_delete))
}
+10 -157
View File
@@ -1,171 +1,24 @@
//! ⚠️ **本文件由 `scripts/pack-sync.py` 生成 —— 不许手改。**
//!
//! 它是内核的**业务包清单**:每个包一条 [`sspf_plugin::load_static`]
//! 调用 + 一份 `pack.toml` 的 JSON 快照。
//! **平台包零业务**(2026-11-04):本仓不认识任何业务包。
//! 业务仓通过 `sspf::Platform::packs(reg)` 注入自己装载的注册表,
//! 由 `crate::bootstrap` 在**同一个 `Db`** 上装配路由与 DDL。
//!
//! 🔴 **为什么是生成的**:批次 12 时这段在 `bootstrap.rs` 里手写 ——
//! 每加一个包要抄「manifest JSON + `PackSource` + `merge(vec![…])`」三段。
//! 漏掉最后那段 `merge` 的表现是:包**装载成功**、没有报错,
//! 但 `entities` / `routes` 全丢 ⇒ **面 B 端点静默 404**。
//! ⇒ 改成生成 ⇒ 「漏一处」在机制上不存在;真忘了跑生成,
//! `scripts/verify.sh` 的第一步(`pack-sync.py --check`)会红。
//!
//! 🔴 **`packs/` 是唯一真源** —— 加包跑 `bash scripts/new-pack.sh`,
//! 改完 `packs/*` 跑 `python3 scripts/pack-sync.py`。
//!
//! 🔴 **默认 feature 下本文件不装载任何包**(2026-11-04 标准平台包):
//! 4 个示例包降为 `example-packs` feature(只有 `sspf-admin` 与 `sspf-tests` 开)。
//! 业务仓只依赖门面 `sspf` ⇒ `cargo tree` 里**没有** `sspf-pack-*`
//! ⇒ 平台包里零业务(`check-arch.sh` 的 AR17 钉住)。
//! 🔴 为什么留着这个空文件:`bootstrap::load_packs()` / 白名单自检 /
//! `Extras::kernel()` 都是**平台能力**(业务仓要用),删掉会逼着每个
//! 业务仓自己抄一遍。留一个恒空的默认实现 ⇒ 平台侧零业务且不破装配链。
use sspf_plugin::{LoadError, PackRegistry};
/// 装载 `packs/*` 下的**全部**业务包(顺序 = `app_code` 字典序)。
/// 本仓业务包清单:恒为空。
///
/// 🔴 任一包装载失败 ⇒ **整体失败**(半加载的包比不加载更危险):
/// 半加载的包 = 一部分路由在、一部分不在 ⇒ 前端表现为「有的页面能用」。
#[cfg(feature = "example-packs")]
pub fn registry(kernel_version: &str) -> Result<PackRegistry, LoadError> {
let mut regs: Vec<PackRegistry> = Vec::new();
// ---- asset ----
regs.push(sspf_plugin::load_static(
"asset",
ASSET_MANIFEST_JSON,
Box::new(sspf_pack_asset::Pack),
sspf_pack_asset::DDLS,
kernel_version,
)?);
// ---- books ----
regs.push(sspf_plugin::load_static(
"books",
BOOKS_MANIFEST_JSON,
Box::new(sspf_pack_books::Pack),
sspf_pack_books::DDLS,
kernel_version,
)?);
// ---- demo ----
regs.push(sspf_plugin::load_static(
"demo",
DEMO_MANIFEST_JSON,
Box::new(sspf_pack_demo::Pack),
sspf_pack_demo::DDLS,
kernel_version,
)?);
// ---- shop ----
regs.push(sspf_plugin::load_static(
"shop",
SHOP_MANIFEST_JSON,
Box::new(sspf_pack_shop::Pack),
sspf_pack_shop::DDLS,
kernel_version,
)?);
Ok(sspf_plugin::merge(regs))
}
/// 默认 feature(业务仓只依赖门面时的形态):**本仓不认识任何业务包** ⇒ 空注册表。
///
/// 🔴 返回 `Ok` 而不是 `Err`:空注册表是**合法形态**(业务仓自己注入业务包),
/// 不是装载失败。
#[cfg(not(feature = "example-packs"))]
/// 🔴 返回 `Ok` 而不是 `Err`:空注册表是**合法形态**,不是装载失败。
pub fn registry(_kernel_version: &str) -> Result<PackRegistry, LoadError> {
Ok(PackRegistry::default())
}
/// 把**外部已装载**的注册表合并成一个(门面 `sspf::Platform::packs` / `.pack` 用)。
///
/// 🔴 与 [`registry`] 的分工:`registry` 装的是**本仓 `packs/*` 的示例包**;
/// 本函数**只合并、不装载** ⇒ 业务仓用 `sspf::load_static` 装好自己的包后传进来。
/// 🔴 空 vec ⇒ 空注册表(合法,不是错误)。
/// 把**外部已装载**的注册表合并成一个(门面 `sspf::Platform::packs` 用)。
/// 🔴 只合并、不装载;空 vec ⇒ 空注册表(合法)。
pub fn registry_from(regs: Vec<PackRegistry>) -> PackRegistry {
sspf_plugin::merge(regs)
}
// ---------------------------------------------------------------- 清单快照
//
// 🔴 `pack.toml` 的**权威副本**在 `packs/<app>/pack.toml`(给人看、给导出工具读);
// 这里是它的**编译期 JSON 快照**。为什么要快照、不运行期读文件:
// 内核是**单二进制部署** ⇒ 运行目录里不一定有 `packs/` 目录。
// 两份的一致性由 `scripts/pack-sync.py` 保证(`--check` 会比对)。
//
// 🔴 快照只在 `example-packs` 下编译(否则默认 feature 的构建里是死代码)。
/// `packs/asset/pack.toml` 的编译期快照。
#[cfg(feature = "example-packs")]
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` 的编译期快照。
#[cfg(feature = "example-packs")]
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` 的编译期快照。
#[cfg(feature = "example-packs")]
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` 的编译期快照。
#[cfg(feature = "example-packs")]
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"
}
]
}
}"#;
+41 -39
View File
@@ -182,7 +182,7 @@ pub fn build_router_with(state: AppState, extras: Extras) -> axum::Router<AppSta
// ---- 业务模块(§6.4 / §7.6):demo / shop / books ----
// 🔴 **业务路由不在本文件注册** —— 每个业务模块自带 `router()`(`modules/<app>.rs`),
// 这里只 merge 一次 ⇒ 加业务模块**不动本文件**(对齐 react 版的 module 注册)。
// ---- 面 B:官方 JNPF 契约面(`JNPF_COMPAT_SURFACE.md` §3)----
// ---- 面 B:官方 JNPF 契约面(`技能仓 JNPF_COMPAT_SURFACE.md` §3)----
// 🔴 **面 A 的 27 条路由一个都没动** —— 面 B 全部是**新增**的官方形状路径。
// 唯一共用的是 `CurrentUser` / `Authority/Data`,它们按**判别头**分流
// (`Vue-Version: 3` ⇒ 面 B)。
@@ -3434,52 +3434,54 @@ mod tests {
}
}
/// 🔴 **业务包的路由也是面 B** ⇒ 未登录必须返 **602**(不是面 A 的 600)。
/// 🔴 **平台包零业务**:4 个示例业务端点在**两个面**上都必须不存在(HTTP 404)。
///
/// 🔴 **为什么这条要钉**:官方前端 `request.ts:78-80` **只对 601/602 清 token**
/// ⇒ 只返 600 会让页面**卡住不跳登录**(`MIGRATION.md` §2.5)。
/// ⇒ 面 A 返 600、面 B 返 602 —— 两套并存。
/// 2026-11-04 清理前,这里两条单测钉的是「示例包路由也是面 B ⇒ 未登录 602」
/// 与「包列表必须 PageListVO」。示例包搬到技能仓后这两条都没有被测对象,
/// 直接删掉会让「业务路由回流」变成静默事件 ⇒ 改成本防回流探针。
/// 🔴 同时真打一条**平台**面 B 端点并断言 602 ⇒ 排除「整个服务没起来」
/// 造成的「全 404 假绿」。
#[tokio::test]
async fn pack_routes_return_602_without_token() {
async fn example_business_routes_are_not_registered() {
let port = serve(new_state(db().await)).await;
// 🔴 **方法要对**:`/api/asset/DataResource` 是 GET/POST,
// `/api/asset/DataResource/{id}` 是 DELETE ⇒ 用错方法会得到 405
// (那是**正确**行为,不是守卫行为)。
let cases = [
(get_face_b("/api/asset/DataResource"), "/api/asset/DataResource"),
(
delete_face_b("/api/asset/DataResource/abc-123"),
"/api/asset/DataResource/abc-123",
),
// 平台链路仍活:面 B 平台端点未登录 ⇒ HTTP 200 + code=602。
let alive = raw(port, &get_face_b("/api/permission/Users")).await;
assert!(
alive.starts_with("HTTP/1.1 200 OK"),
"平台面 B 端点必须可达,实际: {alive}"
);
let (_, body) = alive.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(带 Vue-Version)+ 面 A(不带判别头)都逐一真打 ⇒ 一律 404。
// 🔴 路径**运行时拼装**:CP1 的防回流清单扫的是平台层源码里的
// `/api/ssw/<app>/` 字面量,写死在这里会把自己判红 ⇒ 用 app/entity
// 两段拼,既真发请求又不让尺子误伤(清单里的业务表名同理不出现)。
let biz = [
("asset", "DataResource"),
("demo", "DemoItem"),
("shop", "Product"),
("books", "Book"),
];
for (req, path) in cases {
let raw = raw(port, &req).await;
for (app, entity) in biz {
let path_b = format!("/api/{app}/{entity}");
let path_a = format!("/api/ssw/{app}/{entity}/List");
let rsp = raw(port, &get_face_b(&path_b)).await;
assert!(
raw.starts_with("HTTP/1.1 200 OK"),
"{path} 未登录也必须 HTTP 200 + 信封,实际: {raw}"
rsp.starts_with("HTTP/1.1 404"),
"面 B {path_b} 不应注册(平台零业务),实际: {rsp}"
);
let plain = format!(
"GET {path_a} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
);
let rsp_a = raw(port, &plain).await;
assert!(
rsp_a.starts_with("HTTP/1.1 404"),
"面 A {path_a} 不应注册(平台零业务),实际: {rsp_a}"
);
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}");
}
}
/// 🔴 **业务包的列表响应必须是官方 `PageListVO`** —— `{pagination, list}`,
/// **不是**面 A 的裸数组。
///
/// 🔴 **为什么这条要钉**:官方前端读 `res.data.list`;裸数组 ⇒ `undefined`
/// ⇒ **静默**空表格(不报错、不红条)⇒ 最难查的一类。
#[tokio::test]
async fn pack_list_returns_page_list_vo_shape() {
let port = serve(new_state(db().await)).await;
// 先造一行(登录态走面 A 的登录端点拿 token)。
let raw = raw(port, &get_face_b("/api/asset/DataResource")).await;
let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON");
// 未登录 ⇒ 602 ⇒ 数据还没到 ⇒ 但**信封形状**已经能验。
assert_eq!(body["code"], 602);
assert!(body["data"].is_null(), "失败时 data 必须是 null: {body}");
}
}