From f0c77f731c601b6552f4d861949b06b5d19bbb0c Mon Sep 17 00:00:00 2001 From: admin Date: Sat, 31 Oct 2026 11:47:40 +0800 Subject: [PATCH] =?UTF-8?q?feat(lowcode):=20=E4=BD=8E=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E5=85=83=E6=95=B0=E6=8D=AE=E5=BC=95=E6=93=8E=E7=AC=AC=E4=B8=80?= =?UTF-8?q?=E6=B3=A2=20=E2=80=94=E2=80=94=20=E8=A7=A3=E6=9E=90=20+=20?= =?UTF-8?q?=E6=A0=A1=E9=AA=8C=20+=203=20=E4=B8=AA=E5=8F=AA=E8=AF=BB?= =?UTF-8?q?=E5=B7=A5=E5=85=B7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新 crate sspf-lowcode(纯计算,AR7 钉住不依赖 DB/HTTP):widget 把 54 种 jnpfKey 归成 11 类 (决定「怎么存、能不能接收入参」)/ form 解析控件树 / model 解析表结构 / validate 9 类诊断码 - DDL:base_visual_dev + base_visual_release 逐字对齐官方(21 → 23 张表) - MCP 3 个只读工具:form.list / form.describe / form.validate,后两个支持 inline JSON - 真实样例落盘为 fixture(官方初始化数据的「应收费用」:主表 6 字段 / 子表 8 字段) - 新增 lowcode-smoke.sh 8 条(含两条反自证:改坏 __vModel__ 必被抓、未知控件只 warn) - 影响:测试 306 → 344;十二闸全绿;三条真实方言已写进注释与测试 --- .workbuddy/memory/2026-10-31.md | 49 ++ CLAUDE.md | 14 +- Cargo.lock | 10 + PLAN.md | 23 +- crates/sspf-lowcode/Cargo.toml | 14 + crates/sspf-lowcode/src/form.rs | 541 +++++++++++++ crates/sspf-lowcode/src/lib.rs | 55 ++ crates/sspf-lowcode/src/model.rs | 374 +++++++++ crates/sspf-lowcode/src/validate.rs | 491 ++++++++++++ crates/sspf-lowcode/src/widget.rs | 253 ++++++ .../tests/fixtures/sample_form.json | 751 ++++++++++++++++++ .../tests/fixtures/sample_model.json | 451 +++++++++++ crates/sspf-lowcode/tests/real_sample.rs | 206 +++++ crates/sspf-mcp/src/tools/form.rs | 219 +++++ crates/sspf-mcp/src/tools/mod.rs | 9 +- crates/sspf-store/src/db.rs | 18 +- docs/mcp.md | 43 +- scripts/check-arch.sh | 20 +- scripts/lowcode-smoke.sh | 209 +++++ src/backend/Cargo.toml | 2 + src/backend/db/schema.sql | 89 +++ src/backend/src/main.rs | 10 +- src/backend/src/mcp_adapter.rs | 288 +++++++ src/backend/src/routes.rs | 5 +- 24 files changed, 4122 insertions(+), 22 deletions(-) create mode 100644 crates/sspf-lowcode/Cargo.toml create mode 100644 crates/sspf-lowcode/src/form.rs create mode 100644 crates/sspf-lowcode/src/lib.rs create mode 100644 crates/sspf-lowcode/src/model.rs create mode 100644 crates/sspf-lowcode/src/validate.rs create mode 100644 crates/sspf-lowcode/src/widget.rs create mode 100644 crates/sspf-lowcode/tests/fixtures/sample_form.json create mode 100644 crates/sspf-lowcode/tests/fixtures/sample_model.json create mode 100644 crates/sspf-lowcode/tests/real_sample.rs create mode 100644 crates/sspf-mcp/src/tools/form.rs create mode 100755 scripts/lowcode-smoke.sh diff --git a/.workbuddy/memory/2026-10-31.md b/.workbuddy/memory/2026-10-31.md index 58ae3ab..7a1c8d7 100644 --- a/.workbuddy/memory/2026-10-31.md +++ b/.workbuddy/memory/2026-10-31.md @@ -570,3 +570,52 @@ native 返回 `{count, users}`。不统一形状,P4 对账每一条都是差 | `mcp-smoke` **32/32** | `baseline-smoke` **10/10** | 内存 7 MB + +--- + +## P2-a:低代码元数据引擎(11:28 起) + +目标:**不迁前端**的前提下,让 Rust 侧能存取 baseline 的 visualdev JSON。 +第一波只做「解析 + 校验」,不做动态 CRUD。 + +### 挖到的真实数据(这是这一波最大的收获) + +从 `jnpf-database/PostgreSQL/jnpf_db_init.sql`(123MB)里提取 119 条 `base_visual_dev`: + +- 71 张真表单(dict 形态,含 `fields` 控件树),其余是流程表单(字段映射数组) +- 54 种 `jnpfKey`;top 12 占绝大多数:input 267 / inputNumber 88 / select 71 / + datePicker 71 / textarea 42 / userSelect 36 / table 28 / organizeSelect 25 / + billRule 18 / radio 18 / groupTitle 14 / uploadFile 12 +- 三条方言(都写进了代码注释 + 测试): + 1. **`columnName` 全是 null** ⇒ 只能从 `field` 推导,而推导 ≠ 真实列名 + (`F_CreatorTime` → `f_creatortime`,实际是 `f_creator_time`) + 2. **子表内字段的 `tableName` 指向主表** ⇒ 归属只能看父节点 + 3. `formRef`/`formModel` 是 Vue 变量名(`formRef`/`dataForm` 都见过) + +fixture 落盘:`crates/sspf-lowcode/tests/fixtures/sample_{form,model}.json` +(「应收费用」:主表 6 字段 / 子表 8 字段 / 2 张表定义) + +### 交付 + +- `crates/sspf-lowcode`:widget(54 种控件 → 11 类)/ form / model / validate(9 类诊断码) + —— 纯计算,38 个测试毫秒级(AR7:不许依赖 DB/HTTP) +- DDL:`base_visual_dev` + `base_visual_release` 进 schema.sql(21 → 23 张表) +- MCP 3 个只读工具:`form.list` / `form.describe` / `form.validate` + —— 后两个支持 **inline JSON**,草稿不入库也能校验(也让这一层脱离 DB 可测) +- `scripts/lowcode-smoke.sh` 8 条,含两条**反自证**(改坏字段必被抓 / 未知控件只 warn) + +### 加表踩到的地方(记下来,下次加表照着做) + +加两张表引发**四处**断言失败,必须同步改: + +1. `main.rs` 的 `BASE_TABLES`(17 → 19)—— 不改会「启动失败:孤儿 DDL」 +2. `crates/sspf-store/src/db.rs` 的 `schema_sql_has_expected_table_count`(21 → 23) +3. 同文件 `ddl_tables_parses_every_create_table`(两处 21 → 23) +4. `src/backend/src/routes.rs` 的 `health_reports_ok_tables_and_version`(21 → 23) + +这四处写死是**故意的**:加表必须显式确认四处,漏一处就红。 + +### 数字 + +`cargo test` **344**(+38)|十二道闸门全绿 +| `lowcode-smoke` 8/8 | `mcp-smoke` 32/32 | `baseline-smoke` 10/10 | 内存 7 MB diff --git a/CLAUDE.md b/CLAUDE.md index 5955aa8..1203bfd 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -201,7 +201,7 @@ ssw-platform/ --- -## 6. 验收闸门(十一道,缺一不可) +## 6. 验收闸门(十二道,缺一不可) | 类别 | 脚本 | 测什么 | 当前状态 | |---|---|---|---| @@ -209,19 +209,20 @@ ssw-platform/ | 静态 | `scripts/check-boundary.sh` | 分层红线 CP1–CP6(平台层不许有业务知识) | 已绿(11/11) | | 静态 | `scripts/check-contract.sh` | 契约端点表 ↔ 代码真实路由(CC2–CC10,含官方端点台账 CC10) | 已绿(10/10) | | 静态 | `scripts/check-citations.sh` | 文档引文 `路径:行号` 逐条核对 | 4/4 已绿(192 条引文全解析;CIT3 依赖官方 DDL,缺失则 `⏭`) | -| **静态·架构** | **`scripts/check-arch.sh`** | **crate 依赖纪律 AR1–AR6 + 内存红线 MEM1–MEM2(`--self-test` 反自证)** | **8/8 已绿** | +| **静态·架构** | **`scripts/check-arch.sh`** | **crate 依赖纪律 AR1–AR7 + 内存红线 MEM1–MEM2(`--self-test` 反自证)** | **9/9 已绿** | | **静态·命名** | **`scripts/check-naming.sh`** | **内部标识剥离 NM1–NM3 阻断 + NM4 注释量化(`--strict` 可升级)** | **3/0 已绿(69 处注释技术债)** | | 契约尺子·面 A | `scripts/perm-smoke.sh` | 43 条(面 A 契约闭环 32 + 真实业务模块 asset 9 + 多应用 `App-Code` 路由 2) | 已绿 | | 契约尺子·面 B | `scripts/perm-smoke-jnpf.sh` | 23 条(官方形状 18 + 多应用 `App-Code` 路由 1 + 用户 CRUD 4,诚实记 SKIP) | **23/23 已绿** | | **契约尺子·MCP** | **`scripts/mcp-smoke.sh`** | **32 条:4 元工具上限 / 分层加载 / 自提示 / 业务失败不误报协议错 / 结构注入防护 / 写工具校验 / 授权闭环 / prompts 模板 / stdout 纯 NDJSON** | **32/32 已绿** | +| **契约尺子·低代码** | **`scripts/lowcode-smoke.sh`** | **8 条:真实样例解析(主表 6 字段/子表 8 字段)/ 同构保序 / inline 校验 / 缺参拦截 + 两条反自证(改坏字段必被抓、未知控件不阻断)** | **8/8 已绿** | | **契约尺子·双后端** | **`scripts/baseline-smoke.sh`** | **10 条:基线适配器自动登录 / health 裸对象 / 形状归一化(list→menus、organize→organizeId、裁剪多余键)/ 不支持的 op 发请求前拦下** | **10/10 已绿** | | **运行时·内存** | **`scripts/mem-budget.sh`** | **空载物理内存(vmmap `Physical footprint`)是否 ≤ 预算** | **7 MB / 40 MB 预算 已绿** | 🔴 期望值只有一处:`docs/contract.md` 附录 A(机器可读 `[ENDPOINT]` / `[OFFICIAL]` 等),由 `scripts/contract_expect.py` 解析。 每把尺子结尾比对「实际断言数 vs 契约登记数」,对不上即失败 —— 尺子不会被悄悄改弱。 -**加任何业务模块 / 改任何契约 / 加任何 crate 依赖 / 改任何内部标识,十一道闸门必须全绿才算完成。** +**加任何业务模块 / 改任何契约 / 加任何 crate 依赖 / 改任何内部标识 / 加任何表,十二道闸门必须全绿才算完成。** -🔴 **`cargo test --workspace` 当前 306 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 45 + adapter-baseline 19 + 集成测试)—— +🔴 **`cargo test --workspace` 当前 344 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 45 + adapter-baseline 19 + lowcode 38 + 集成测试)—— 拆 crate 后总数会变,**不许把断言数写死**,跑一遍看实际值。 cipher 自证(免 node):`./target/release/ssw-platform --enc 123456`。 @@ -272,18 +273,19 @@ cp .env.example .env && ./run.sh install && ./run.sh dev ```bash cargo build --release # 编译(workspace 根,含 crates/* 与 packs/*) -cargo test --workspace # 单测(当前 306 条) +cargo test --workspace # 单测(当前 344 条) bash run.sh dev # 起后端(30010) + 前端(5173) bash scripts/perm-smoke.sh # 面 A 43 条 bash scripts/perm-smoke-jnpf.sh # 面 B 23 条 bash scripts/check-boundary.sh # 分层红线 CP1–CP6 bash scripts/check-contract.sh # 契约端点 ↔ 代码路由 对账 bash scripts/check-module.sh # 业务模块 10 接触点 -bash scripts/check-arch.sh # crate 依赖纪律 AR1–AR6 + 内存红线 MEM1–MEM2 +bash scripts/check-arch.sh # crate 依赖纪律 AR1–AR7 + 内存红线 MEM1–MEM2 bash scripts/check-arch.sh --self-test # 反自证:造违规必须被抓到 bash scripts/check-naming.sh # 内部标识剥离(NM1–NM3 阻断 / NM4 注释量化) bash scripts/check-naming.sh --strict # 注释里的原厂名也算红(技术债清零时用) bash scripts/mcp-smoke.sh # MCP 工具层契约 32 条(4 元工具 + 分层加载 + 授权闭环 + prompts) +bash scripts/lowcode-smoke.sh # 低代码 8 条(表单解析 + 校验 + 反自证) bash scripts/baseline-smoke.sh # 双后端契约 10 条(HTTP 适配器 + 形状归一化) cargo build -p sspf-adapter-baseline --example probe # baseline-smoke 依赖的探针 bash scripts/mem-budget.sh # 空载内存实测(P0 出口判据,预算 40 MB) diff --git a/Cargo.lock b/Cargo.lock index 3a20db0..b2289a3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1093,6 +1093,15 @@ dependencies = [ "uuid", ] +[[package]] +name = "sspf-lowcode" +version = "0.1.0" +dependencies = [ + "serde", + "serde_json", + "sspf-contract", +] + [[package]] name = "sspf-mcp" version = "0.1.0" @@ -1146,6 +1155,7 @@ dependencies = [ "serde_json", "serde_urlencoded", "sspf-contract", + "sspf-lowcode", "sspf-mcp", "sspf-store", "tokio", diff --git a/PLAN.md b/PLAN.md index b7cdbb2..d424490 100644 --- a/PLAN.md +++ b/PLAN.md @@ -254,7 +254,7 @@ ssw-platform/ | 面 B 契约端点 | ✅ 147 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) | | `base_*` DDL | ✅ 21 张逐字对齐 | 全量 331 张中的必需集 | 按域补 | | 平台/业务分层 | ✅ `check-boundary.sh` 钉住 | 升级为 crate 级隔离 | **P0 已拆 contract / store / sdk;asset 包可独立编译;`jnpf.rs`→`face_b.rs`** | -| 低代码元数据引擎 | ❌ 无 | visualdev 同构 + 动态 CRUD | **全新,P2 主体** | +| 低代码元数据引擎 | 🟡 **P2-a 完成**:解析 + 校验 + 3 个只读工具 | visualdev 同构 + 动态 CRUD + 发布 | **动态 CRUD 待做(P2-b)** | | 业务包格式 | 🟡 `pack.toml` 已定稿、`packs/asset` 已有样板 | 导入导出工具 | **P3** | | MCP 工具面 | 🟡 **P1 主体完成**:4 元工具 + registry + 分层加载 + 双适配器 + 19 个业务工具 + 3 个流程模板 | 约 55 个业务工具(补 form/model/workflow) | P1 收尾 | | 影子对账 | ❌ 无 | 语料库 + 归一化比对 | **全新,P4** | @@ -856,6 +856,27 @@ tools/diff-harness/ | 出口 | 基线平台导出的表单 JSON,不改一个字段能在 SSPF 上渲染 + 存取;动态 CRUD 通过列白名单安全测试;Rhai 逃逸测试(`eval`/IO/递归/超深表达式)全部被拒 | | 风险 | 表单 JSON 方言多(不同控件)⇒ 先覆盖 top 10 控件,其余降级 input | +**P2 已完成(2026-10-31,第一波 P2-a)**: + +- `crates/sspf-lowcode`:`form`(控件树解析)/ `model`(表结构解析)/ `widget`(54 种 jnpfKey 分类) + / `validate`(9 类诊断码),**纯计算**,38 个测试毫秒级跑完(AR7 钉住不许依赖 DB) +- DDL:`base_visual_dev` / `base_visual_release` 进 `schema.sql`,列与官方逐字一致(21 → 23 张表) +- 真实样例落地为 fixture:官方初始化数据里的「应收费用」表单(主表 6 字段 / 子表 8 字段) +- MCP 工具 3 个(只读):`form.list` / `form.describe` / `form.validate`;后两个支持 **inline JSON** + (不用入库就能校验草稿) +- `scripts/lowcode-smoke.sh` 8 条,含**两条反自证**:改坏 `__vModel__` 必须被抓、未知控件必须只 warn + +**第一波刻意没做的**:动态 CRUD(写数据)、写表单定义。原因:写的前置是「解析 + 校验被真实数据验证透」, +否则等于让 AI 生成前端画不出来的 JSON。 + +**实测发现的三条方言**(都已写进代码注释与测试): + +1. `f_tables_data` 的 `columnName` **全是 null** ⇒ 只能从 `field` 推导,而推导**不等于**真实列名 + (`F_CreatorTime` → `f_creatortime`,实际列是 `f_creator_time`) + ⇒ 本 crate 只保证「表单 ↔ 模型设计稿」自洽;与真实库的一致性要拿 `information_schema` 比(P2-b) +2. 子表内字段的 `tableName` 指向**主表**,不是子表 ⇒ 子表归属只能看父节点 +3. `formRef` / `formModel` 是 Vue 变量名,不是固定常量(见过 `elForm`/`formData`,也见过 `formRef`/`dataForm`) + ### P3 · 业务包 + 动态库 + 双向迁移(约 5 周) | 项 | 内容 | diff --git a/crates/sspf-lowcode/Cargo.toml b/crates/sspf-lowcode/Cargo.toml new file mode 100644 index 0000000..7c76f72 --- /dev/null +++ b/crates/sspf-lowcode/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "sspf-lowcode" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +description = "低代码元数据引擎:解析/校验/生成 baseline 的 visualdev JSON(不迁前端的关键层)" + +[dependencies] +# 🔴 只依赖契约层与序列化 —— 本 crate 是**纯计算**(解析 + 校验 + SQL 生成), +# 不碰数据库、不碰 HTTP。动态 CRUD 的执行由调用方(内核 / 适配器)负责。 +# 这条纪律(AR7)保证 lowcode 能被单测、能被 CLI、能被 MCP 直接复用。 +sspf-contract = { path = "../sspf-contract" } +serde = { workspace = true } +serde_json = { workspace = true } diff --git a/crates/sspf-lowcode/src/form.rs b/crates/sspf-lowcode/src/form.rs new file mode 100644 index 0000000..b927eec --- /dev/null +++ b/crates/sspf-lowcode/src/form.rs @@ -0,0 +1,541 @@ +//! form —— 解析 baseline 的 `f_form_data`(表单控件树)。 +//! +//! ## 数据结构(实测自官方初始化数据,71 张表单) +//! +//! ```json +//! { +//! "formRef": "elForm", +//! "formModel": "formData", +//! "labelPosition": "right", +//! "labelWidth": 100, +//! "formRules": "rules", +//! "popupType": "dialog", +//! "primaryKeyPolicy": 1, +//! "concurrencyLock": false, +//! "logicalDelete": true, +//! "fields": [ +//! { +//! "__config__": { +//! "formId": 101, +//! "jnpfKey": "input", +//! "layout": "colFormItem", +//! "tag": "JnpfInput", +//! "label": "房间号", +//! "tableName": "test_receivable", +//! "required": false, +//! "span": 12, +//! "visibility": ["pc", "app"] +//! }, +//! "__vModel__": "F_Room", +//! "placeholder": "请输入" +//! } +//! ] +//! } +//! ``` +//! +//! ## 三个必须记住的方言(踩错就是静默错数据) +//! +//! 1. **`__vModel__` 是 `F_` 开头的大写**(`F_Room`),而物理列是小写 `f_room`。 +//! 映射规则只有一条:`f_` + `__vModel__` 去前缀后转小写。 +//! 2. **`rowFormItem` 是布局容器**,本身不占列;它的 `children` 才是控件。 +//! 3. **`table` 是子表**,它的 `children` 属于**另一张物理表** +//! (`__config__.tableName` 指明的那个),不能混进主表字段。 +//! +//! ## 同构原则 +//! +//! [`FormSchema::raw`] 保留原始 JSON 一字不动。所有解析结果都是**视图**, +//! 保存时写回原始的 `raw` —— 这样前端拿到的表单和它自己存的一模一样, +//! 不会因为我们「顺手规范化」了键顺序而白屏。 + +use serde_json::{Map, Value}; + +use crate::widget::{classify, unknown_hint, WidgetKind}; + +/// 解析失败的原因(结构化,便于回报给 AI)。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum FormError { + /// 不是 JSON 对象。 + NotAnObject, + /// 缺 `fields` 数组。 + MissingFields, + /// `fields` 不是数组。 + FieldsNotArray, +} + +impl FormError { + /// 机器可读码。 + pub fn code(&self) -> &'static str { + match self { + FormError::NotAnObject => "FORM_NOT_OBJECT", + FormError::MissingFields => "FORM_MISSING_FIELDS", + FormError::FieldsNotArray => "FORM_FIELDS_NOT_ARRAY", + } + } + + /// 人话说明 + 怎么修。 + pub fn message(&self) -> &'static str { + match self { + FormError::NotAnObject => { + "f_form_data 不是 JSON 对象。流程表单的 f_form_data 是**字段映射数组**\ + ([{filedName,filedId,…}]),不是控件树 —— 那种表单不属于本引擎的处理范围" + } + FormError::MissingFields => { + "f_form_data 缺少 fields 数组 —— 这不是 visualdev 表单定义,\ + 可能是列表页配置(那种结构有 columnList / ruleList)" + } + FormError::FieldsNotArray => "f_form_data.fields 存在但不是数组", + } + } +} + +/// 一个控件节点。 +#[derive(Debug, Clone, PartialEq)] +pub struct FieldNode { + /// `__vModel__`(如 `F_Room`)。系统字段可能为空串。 + pub v_model: String, + /// 显示名(`__config__.label`)。 + pub label: String, + /// 控件类型原文(`__config__.jnpfKey`,缺失时退回节点自身的 `jnpfKey`)。 + pub jnpf_key: String, + /// 控件类别(决定怎么存)。 + pub widget: WidgetKind, + /// 布局类型:`colFormItem`(控件)/ `rowFormItem`(容器)。 + pub layout: String, + /// 该控件所属物理表(`__config__.tableName`)。 + pub table_name: Option, + /// 是否必填。 + pub required: bool, + /// 可见端:`["pc"]` / `["pc","app"]`。 + pub visibility: Vec, + /// 是否隐藏(`noShow`)。 + pub no_show: bool, + /// `__config__.formId`(表单内唯一序号,用于定位)。 + pub form_id: Option, + /// 子控件(仅 `rowFormItem` 与子表有)。 + pub children: Vec, +} + +impl FieldNode { + /// 是否是布局容器(本身不占列,但孩子可能占)。 + pub fn is_container(&self) -> bool { + self.layout == "rowFormItem" + } + + /// 是否是子表节点。 + pub fn is_sub_table(&self) -> bool { + self.widget == WidgetKind::SubTable + } + + /// 该节点是否占**主表**的一列。 + /// + /// 布局容器、子表本身都不占;子表里的字段属于别的表。 + pub fn occupies_main_column(&self) -> bool { + !self.is_container() && self.widget.occupies_column() + } + + /// `__vModel__` → 物理列名(`F_Room` → `f_room`)。 + /// + /// 空 `__vModel__` ⇒ `None`(系统字段常见)。 + pub fn column_name(&self) -> Option { + v_model_to_column(&self.v_model) + } +} + +/// `__vModel__` → 物理列名。 +/// +/// 规则(实测唯一正确的一条): +/// - 去掉任意数量的 `F_` / `f_` 前缀(官方两种写法都出现过) +/// - 其余部分整体转**小写**,不做驼峰拆分 +/// +/// 🔴 **不要做驼峰转下划线**:`F_CertificatesType` 对应的列是 +/// `f_certificates_type`,但 `F_Building` 对应 `f_building`(没有下划线)。 +/// 官方列名由建表时的人工输入决定,没有机械规则 —— 所以这里只做 +/// 「前缀剥离 + 小写」,真实列名一律以 `f_tables_data` 为准。 +pub fn v_model_to_column(v_model: &str) -> Option { + let s = v_model.trim(); + if s.is_empty() { + return None; + } + let stripped = s + .strip_prefix("F_") + .or_else(|| s.strip_prefix("f_")) + .unwrap_or(s); + if stripped.is_empty() { + return None; + } + Some(format!("f_{}", stripped.to_lowercase())) +} + +/// 解析后的表单(保留原始 JSON)。 +#[derive(Debug, Clone)] +pub struct FormSchema { + /// 原始 JSON —— 保存时原样写回(同构)。 + pub raw: Value, + /// 表单引用名(`formRef`)。 + pub form_ref: String, + /// 绑定的数据对象名(`formModel`,通常是 `formData`)。 + pub form_model: String, + /// 标签位置(`labelPosition`)。 + pub label_position: String, + /// 标签宽度。 + pub label_width: i64, + /// 主键策略(`primaryKeyPolicy`)。 + pub primary_key_policy: Option, + /// 是否并发锁(`concurrencyLock`)。 + pub concurrency_lock: Option, + /// 是否逻辑删除(`logicalDelete`)。 + pub logical_delete: Option, + /// 顶层控件树。 + pub fields: Vec, +} + +impl FormSchema { + /// 解析 `f_form_data`。 + pub fn parse(raw: &Value) -> Result { + let Some(obj) = raw.as_object() else { + return Err(FormError::NotAnObject); + }; + let Some(fields_val) = obj.get("fields") else { + return Err(FormError::MissingFields); + }; + let Some(arr) = fields_val.as_array() else { + return Err(FormError::FieldsNotArray); + }; + + let fields = arr.iter().filter_map(parse_node).collect(); + + Ok(Self { + raw: raw.clone(), + form_ref: str_of(obj, "formRef"), + form_model: str_of(obj, "formModel"), + label_position: str_of(obj, "labelPosition"), + label_width: obj.get("labelWidth").and_then(Value::as_i64).unwrap_or(0), + primary_key_policy: obj.get("primaryKeyPolicy").and_then(Value::as_i64), + concurrency_lock: obj.get("concurrencyLock").and_then(Value::as_bool), + logical_delete: obj.get("logicalDelete").and_then(Value::as_bool), + fields, + }) + } + + /// 从 JSON 文本解析。 + pub fn from_str(s: &str) -> Result { + let v: Value = serde_json::from_str(s).map_err(|_| FormError::NotAnObject)?; + Self::parse(&v) + } + + /// 扁平化全部节点(含容器与子表字段),深度优先。 + pub fn all_nodes(&self) -> Vec<&FieldNode> { + fn walk<'a>(nodes: &'a [FieldNode], out: &mut Vec<&'a FieldNode>) { + for n in nodes { + out.push(n); + walk(&n.children, out); + } + } + let mut out = Vec::new(); + walk(&self.fields, &mut out); + out + } + + /// **主表**要存的字段(排除布局、子表本身、子表内的字段)。 + /// + /// 这就是动态 CRUD 的列白名单来源 —— 顺序保持 JSON 里的原始顺序。 + pub fn main_fields(&self) -> Vec<&FieldNode> { + let mut out = Vec::new(); + for n in self.fields.iter() { + collect_main(n, &mut out); + } + out + } + + /// 子表清单(每个子表节点一项)。 + pub fn sub_tables(&self) -> Vec<&FieldNode> { + self.all_nodes() + .into_iter() + .filter(|n| n.is_sub_table()) + .collect() + } + + /// 主表字段对应的物理列名(去重、保序)。 + pub fn main_columns(&self) -> Vec { + let mut out: Vec = Vec::new(); + for f in self.main_fields() { + if let Some(c) = f.column_name() { + if !out.contains(&c) { + out.push(c); + } + } + } + out + } + + /// 出现过的主表名(去重)。 + pub fn table_names(&self) -> Vec { + let mut out: Vec = Vec::new(); + for n in self.all_nodes() { + if let Some(t) = &n.table_name { + if !t.is_empty() && !out.contains(t) { + out.push(t.clone()); + } + } + } + out + } + + /// 未知控件清单(用于警告)。 + pub fn unknown_widgets(&self) -> Vec<&FieldNode> { + self.all_nodes() + .into_iter() + .filter(|n| n.widget == WidgetKind::Unknown) + .collect() + } +} + +/// 递归收集主表字段。 +fn collect_main<'a>(node: &'a FieldNode, out: &mut Vec<&'a FieldNode>) { + if node.is_sub_table() { + // 子表本身与它的孩子都不进主表 + return; + } + if node.is_container() { + for c in &node.children { + collect_main(c, out); + } + return; + } + if node.widget.occupies_column() { + out.push(node); + } +} + +fn str_of(obj: &Map, key: &str) -> String { + obj.get(key) + .and_then(Value::as_str) + .unwrap_or("") + .to_string() +} + +/// 解析单个节点;结构不像控件时返回 `None`。 +fn parse_node(v: &Value) -> Option { + let obj = v.as_object()?; + let cfg = obj + .get("__config__") + .and_then(Value::as_object) + .cloned() + .unwrap_or_default(); + + // jnpfKey:优先 __config__,退回节点自身 + let jnpf_key = cfg + .get("jnpfKey") + .and_then(Value::as_str) + .or_else(|| obj.get("jnpfKey").and_then(Value::as_str)) + .unwrap_or("") + .to_string(); + + let layout = cfg + .get("layout") + .and_then(Value::as_str) + .unwrap_or("colFormItem") + .to_string(); + + let v_model = obj + .get("__vModel__") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + + let visibility = cfg + .get("visibility") + .and_then(Value::as_array) + .map(|a| { + a.iter() + .filter_map(Value::as_str) + .map(str::to_string) + .collect() + }) + .unwrap_or_default(); + + let children: Vec = cfg + .get("children") + .and_then(Value::as_array) + .map(|a| a.iter().filter_map(parse_node).collect()) + .unwrap_or_default(); + + // 🔴 有些节点(新版控件)把子项挂在顶层 children,而不是 __config__ 里 + let children = if children.is_empty() { + obj.get("children") + .and_then(Value::as_array) + .map(|a| a.iter().filter_map(parse_node).collect()) + .unwrap_or_default() + } else { + children + }; + + // 既无 jnpfKey 又无 vModel 的节点不是控件(可能是不认识的结构),跳过 + if jnpf_key.is_empty() && v_model.is_empty() { + return None; + } + + let widget = classify(&jnpf_key); + + Some(FieldNode { + v_model, + label: str_of(&cfg, "label"), + jnpf_key, + widget, + layout, + table_name: cfg.get("tableName").and_then(Value::as_str).map(str::to_string), + required: cfg.get("required").and_then(Value::as_bool).unwrap_or(false), + visibility, + no_show: cfg.get("noShow").and_then(Value::as_bool).unwrap_or(false), + form_id: cfg.get("formId").and_then(Value::as_i64), + children, + }) +} + +/// 把未知控件汇总成一条人话警告(供 `form.validate` 输出)。 +pub fn unknown_warning(nodes: &[&FieldNode]) -> Option { + if nodes.is_empty() { + return None; + } + let keys: Vec<&str> = nodes.iter().map(|n| n.jnpf_key.as_str()).collect(); + Some(format!( + "{} 个未知控件({})—— {}", + nodes.len(), + keys.join(", "), + unknown_hint(keys[0]) + )) +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn minimal_form() -> Value { + json!({ + "formRef": "elForm", + "formModel": "formData", + "labelPosition": "right", + "labelWidth": 100, + "fields": [ + { + "__config__": { "jnpfKey": "input", "layout": "colFormItem", + "label": "姓名", "tableName": "t_demo", "required": true }, + "__vModel__": "F_Name" + }, + { + "__config__": { "jnpfKey": "inputNumber", "layout": "colFormItem", + "label": "年龄", "tableName": "t_demo" }, + "__vModel__": "F_Age" + }, + { + "__config__": { "jnpfKey": "groupTitle", "layout": "colFormItem", "label": "分组" }, + "__vModel__": "" + } + ] + }) + } + + #[test] + fn parses_minimal_form() { + let f = FormSchema::parse(&minimal_form()).unwrap(); + assert_eq!(f.form_ref, "elForm"); + assert_eq!(f.label_width, 100); + assert_eq!(f.fields.len(), 3); + // 主表字段排除布局控件 + let cols = f.main_columns(); + assert_eq!(cols, vec!["f_name", "f_age"]); + } + + /// 🔴 vModel → 列名:只剥前缀 + 转小写,**不做驼峰转下划线**。 + #[test] + fn v_model_mapping_is_prefix_strip_plus_lowercase() { + assert_eq!(v_model_to_column("F_Room").as_deref(), Some("f_room")); + assert_eq!(v_model_to_column("f_room").as_deref(), Some("f_room")); + assert_eq!( + v_model_to_column("F_CertificatesType").as_deref(), + Some("f_certificatestype"), + "不做驼峰拆分 —— 真实列名以 f_tables_data 为准" + ); + assert_eq!(v_model_to_column("").as_deref(), None); + assert_eq!(v_model_to_column("F_").as_deref(), None); + } + + #[test] + fn rejects_wrong_shapes() { + assert_eq!(FormSchema::parse(&json!([1, 2])).unwrap_err(), FormError::NotAnObject); + assert_eq!(FormSchema::parse(&json!({"a": 1})).unwrap_err(), FormError::MissingFields); + assert_eq!( + FormSchema::parse(&json!({"fields": "x"})).unwrap_err(), + FormError::FieldsNotArray + ); + } + + /// 错误消息必须能区分「流程表单的字段映射」和「真的坏数据」。 + #[test] + fn error_messages_are_actionable() { + assert!(FormError::NotAnObject.message().contains("流程表单")); + assert!(FormError::MissingFields.message().contains("列表页配置")); + } + + /// 布局容器(rowFormItem)不占列,但它的孩子要进主表。 + #[test] + fn row_container_children_join_main_fields() { + let v = json!({ + "formRef": "elForm", + "fields": [{ + "__config__": { "jnpfKey": "row", "layout": "rowFormItem", "label": "行" }, + "__vModel__": "", + "children": [{ + "__config__": { "jnpfKey": "input", "layout": "colFormItem", "label": "备注" }, + "__vModel__": "F_Remark" + }] + }] + }); + let f = FormSchema::parse(&v).unwrap(); + assert_eq!(f.main_columns(), vec!["f_remark"], "容器本身不占列,孩子占"); + } + + /// 子表:本身不占主表列,它的字段也不进主表(属于另一张表)。 + #[test] + fn sub_table_is_isolated_from_main_columns() { + let v = json!({ + "formRef": "elForm", + "fields": [ + { "__config__": { "jnpfKey": "input", "tableName": "t_main" }, "__vModel__": "F_Title" }, + { + "__config__": { "jnpfKey": "table", "layout": "rowFormItem", + "tableName": "t_child", "label": "明细" }, + "__vModel__": "tableField1", + "children": [ + { "__config__": { "jnpfKey": "input", "tableName": "t_child" }, "__vModel__": "F_Item" } + ] + } + ] + }); + let f = FormSchema::parse(&v).unwrap(); + assert_eq!(f.main_columns(), vec!["f_title"], "子表字段不能混进主表"); + assert_eq!(f.sub_tables().len(), 1); + assert_eq!(f.sub_tables()[0].table_name.as_deref(), Some("t_child")); + assert_eq!(f.table_names().len(), 2); + } + + #[test] + fn unknown_widget_is_reported_but_not_fatal() { + let v = json!({ + "formRef": "elForm", + "fields": [{ "__config__": { "jnpfKey": "futureWidget" }, "__vModel__": "F_X" }] + }); + let f = FormSchema::parse(&v).unwrap(); + let unknown = f.unknown_widgets(); + assert_eq!(unknown.len(), 1); + assert!(unknown_warning(&unknown).unwrap().contains("futureWidget")); + } + + #[test] + fn raw_is_preserved_verbatim() { + let v = minimal_form(); + let f = FormSchema::parse(&v).unwrap(); + assert_eq!(f.raw, v, "raw 必须一字不动(同构)"); + } +} diff --git a/crates/sspf-lowcode/src/lib.rs b/crates/sspf-lowcode/src/lib.rs new file mode 100644 index 0000000..69afec7 --- /dev/null +++ b/crates/sspf-lowcode/src/lib.rs @@ -0,0 +1,55 @@ +//! sspf-lowcode —— 低代码元数据引擎(**纯计算**,不碰 DB / HTTP)。 +//! +//! ## 它为什么存在 +//! +//! 项目第 5 条要求「不迁前端/移动端代码,复用现有资产」。这意味着前端那套 +//! Vue 渲染器继续用,Rust 侧只需要做到一件事: +//! +//! > **同构存取 baseline 的 `base_visual_dev` 里那几个 JSON 字段。** +//! +//! 前端不关心后端是 Java 还是 Rust —— 它只认 `f_form_data` / `f_column_data` / +//! `f_tables_data` 三个 JSON 字符串。所以本 crate 的全部工作就是: +//! +//! ```text +//! f_form_data ──parse──▶ FormSchema (控件树:字段、必填、子表、控件类型) +//! f_tables_data ─parse──▶ ModelSchema (表结构:表、列、主键、类型) +//! │ +//! └─validate─▶ Report(表单声明的字段,表里真有那些列吗) +//! ``` +//! +//! ## 三层职责,别混 +//! +//! | 层 | 归属 | 干什么 | +//! |---|---|---| +//! | **渲染** | 前端(Vue,不动) | 读 JSON 画表单 | +//! | **解析 / 校验 / SQL 生成** | 本 crate | 纯函数,可单测 | +//! | **执行** | 内核 / MCP 适配器 | 真正连库、跑 SQL | +//! +//! ⇒ 本 crate **不引入 `pglite` / `axum` / `tokio`**(AR7)。 +//! 这样它既能被内核用,也能被 CLI、MCP、离线校验工具用 —— 而且测试不需要起数据库。 +//! +//! ## 四个必须记住的方言(都在各模块头部详述) +//! +//! 1. `__vModel__` 是 `F_` 开头大写,物理列是小写;映射只做「剥前缀 + 转小写」 +//! 2. `f_tables_data` 的 `columnName` **常常是 null**,要用 `field` 推导 +//! 3. `rowFormItem` 是布局容器,不占列,孩子才占 +//! 4. `table` 是子表,它的字段属于**另一张物理表** +//! +//! ## 为什么「不改一个字段」是可验证的 +//! +//! [`FormSchema::raw`] / [`ModelSchema::raw`] 保留原始 JSON 一字不动, +//! 保存时原样写回。解析结果只是**只读视图**, +//! 测试 `real_sample.rs` 用官方初始化数据里的真表单做基线断言。 + +pub mod form; +pub mod model; +pub mod validate; +pub mod widget; + +pub use form::{v_model_to_column, FieldNode, FormError, FormSchema}; +pub use model::{ColumnDef, ModelError, ModelSchema, TableSchema}; +pub use validate::{validate, Diagnostic, Report, Severity}; +pub use widget::{classify, WidgetKind}; + +/// 版本(与 workspace 一致,供 MCP 输出用)。 +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/crates/sspf-lowcode/src/model.rs b/crates/sspf-lowcode/src/model.rs new file mode 100644 index 0000000..8d6731c --- /dev/null +++ b/crates/sspf-lowcode/src/model.rs @@ -0,0 +1,374 @@ +//! model —— 解析 baseline 的 `f_tables_data`(表结构定义)。 +//! +//! ## 数据结构(实测) +//! +//! ```json +//! [ +//! { +//! "table": "test_receivable", +//! "tableName": "应收费用主表", +//! "typeId": "1", // "1" = 主表, "0" = 子表 +//! "relationTable": "", +//! "relationField": "", +//! "tableField": "", +//! "fields": [ +//! { +//! "field": "F_Id", // 设计态字段名(权威) +//! "columnName": null, // 物理列名 —— **常常是 null**! +//! "fieldName": "主键", // 显示名 +//! "dataType": "varchar", +//! "dataLength": "50", +//! "primaryKey": 1, +//! "allowNull": 0, +//! "autoIncrement": 0, +//! "identity": 0 +//! } +//! ] +//! } +//! ] +//! ``` +//! +//! ## 🔴 最重要的一条:`columnName` 不可信 +//! +//! 实测数据里 `columnName` **大量为 null** ——「设计完还没建表」的商品态就是这样。 +//! 所以物理列名必须从 `field` 推导(规则与 `form::v_model_to_column` 同一份实现): +//! +//! ```text +//! F_Id → f_id +//! F_Room → f_room +//! F_CertificatesType → f_certificatestype ← 注意没有下划线 +//! ``` +//! +//! ⇒ **不要指望「驼峰转下划线」**。真实列名最终以数据库 `information_schema` 为准, +//! 本模块只负责「设计态 → 预期列名」的推导与一致性校验。 + +use serde_json::{Map, Value}; + +use crate::form::v_model_to_column; + +/// 解析失败原因。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ModelError { + /// 不是数组。 + NotAnArray, + /// 空数组。 + Empty, +} + +impl ModelError { + /// 机器可读码。 + pub fn code(&self) -> &'static str { + match self { + ModelError::NotAnArray => "MODEL_NOT_ARRAY", + ModelError::Empty => "MODEL_EMPTY", + } + } + + /// 人话说明。 + pub fn message(&self) -> &'static str { + match self { + ModelError::NotAnArray => { + "f_tables_data 不是数组 —— 它应该是多张表的定义列表([{table,tableName,typeId,fields}])" + } + ModelError::Empty => "f_tables_data 是空数组,没有任何表定义", + } + } +} + +/// 一列的定义。 +#[derive(Debug, Clone, PartialEq)] +pub struct ColumnDef { + /// 设计态字段名(`F_Id`)。**这是权威字段名**。 + pub field: String, + /// 官方给的物理列名 —— 可能为 null(尚未建表)。 + pub column_name: Option, + /// 显示名(`主键`)。 + pub field_name: String, + /// 数据类型(`varchar` / `int4` / `timestamp` …)。 + pub data_type: String, + /// 长度(字符串形态,官方如此)。 + pub data_length: String, + /// 是否主键。 + pub primary_key: bool, + /// 是否允许 NULL。 + pub allow_null: bool, + /// 是否自增。 + pub auto_increment: bool, +} + +impl ColumnDef { + /// 实际使用的物理列名:`columnName` 优先,否则从 `field` 推导。 + /// + /// 🔴 只在**非空**时才信 `columnName` —— 实测大量为 `null`。 + pub fn resolved_column(&self) -> Option { + match &self.column_name { + Some(c) if !c.is_empty() => Some(c.to_lowercase()), + _ => v_model_to_column(&self.field), + } + } +} + +/// 一张表的定义。 +#[derive(Debug, Clone, PartialEq)] +pub struct TableSchema { + /// 物理表名。 + pub table: String, + /// 显示名。 + pub table_name: String, + /// `"1"` = 主表,`"0"` = 子表。 + pub type_id: String, + /// 列定义(顺序即建表顺序)。 + pub fields: Vec, +} + +impl TableSchema { + /// 是否主表。 + pub fn is_main(&self) -> bool { + self.type_id == "1" + } + + /// 按 `F_xxx` 风格的设计态字段名找列(大小写不敏感)。 + pub fn column_by_field(&self, field: &str) -> Option<&ColumnDef> { + self.fields + .iter() + .find(|c| c.field.eq_ignore_ascii_case(field)) + } + + /// 按物理列名找列(大小写不敏感)。 + pub fn column_by_name(&self, name: &str) -> Option<&ColumnDef> { + self.fields.iter().find(|c| { + c.resolved_column() + .is_some_and(|r| r.eq_ignore_ascii_case(name)) + }) + } + + /// 全部物理列名(已推导)。 + pub fn column_names(&self) -> Vec { + self.fields + .iter() + .filter_map(|c| c.resolved_column()) + .collect() + } + + /// 主键列名(可能为空 —— 设计态没标主键)。 + pub fn primary_keys(&self) -> Vec { + self.fields + .iter() + .filter(|c| c.primary_key) + .filter_map(|c| c.resolved_column()) + .collect() + } +} + +/// 解析后的模型(保留原始 JSON)。 +#[derive(Debug, Clone)] +pub struct ModelSchema { + /// 原始 JSON —— 同构保存时原样写回。 + pub raw: Value, + /// 表清单。 + pub tables: Vec, +} + +impl ModelSchema { + /// 解析 `f_tables_data`。 + pub fn parse(raw: &Value) -> Result { + let Some(arr) = raw.as_array() else { + return Err(ModelError::NotAnArray); + }; + if arr.is_empty() { + return Err(ModelError::Empty); + } + Ok(Self { + raw: raw.clone(), + tables: arr.iter().filter_map(parse_table).collect(), + }) + } + + /// 从 JSON 文本解析。 + pub fn from_str(s: &str) -> Result { + let v: Value = serde_json::from_str(s).map_err(|_| ModelError::NotAnArray)?; + Self::parse(&v) + } + + /// 主表(`typeId == "1"`)。多个主表时取第一个。 + pub fn main_table(&self) -> Option<&TableSchema> { + self.tables.iter().find(|t| t.is_main()) + } + + /// 按物理表名查找(大小写不敏感 —— 官方数据里有大小写混用)。 + pub fn table(&self, name: &str) -> Option<&TableSchema> { + self.tables + .iter() + .find(|t| t.table.eq_ignore_ascii_case(name)) + } + + /// 子表清单。 + pub fn sub_tables(&self) -> Vec<&TableSchema> { + self.tables.iter().filter(|t| !t.is_main()).collect() + } +} + +fn parse_table(v: &Value) -> Option { + let obj = v.as_object()?; + let table = obj.get("table").and_then(Value::as_str)?.trim().to_string(); + if table.is_empty() { + return None; + } + Some(TableSchema { + table, + table_name: str_of(obj, "tableName"), + type_id: match obj.get("typeId") { + Some(Value::String(s)) => s.clone(), + Some(Value::Number(n)) => n.to_string(), + _ => "0".to_string(), + }, + fields: obj + .get("fields") + .and_then(Value::as_array) + .map(|a| a.iter().filter_map(parse_column).collect()) + .unwrap_or_default(), + }) +} + +fn parse_column(v: &Value) -> Option { + let obj = v.as_object()?; + let field = obj.get("field").and_then(Value::as_str)?.trim().to_string(); + if field.is_empty() { + return None; + } + Some(ColumnDef { + field, + column_name: obj + .get("columnName") + .and_then(Value::as_str) + .map(str::to_string), + field_name: str_of(obj, "fieldName"), + data_type: str_of(obj, "dataType"), + data_length: match obj.get("dataLength") { + Some(Value::String(s)) => s.clone(), + Some(Value::Number(n)) => n.to_string(), + _ => String::new(), + }, + primary_key: truthy(obj.get("primaryKey")), + allow_null: truthy(obj.get("allowNull")), + auto_increment: truthy(obj.get("autoIncrement")), + }) +} + +/// 官方的布尔字段是 `0/1` 数字,但也见过 `true/false` 与 `"1"` 字符串。 +fn truthy(v: Option<&Value>) -> bool { + match v { + Some(Value::Bool(b)) => *b, + Some(Value::Number(n)) => n.as_i64().unwrap_or(0) != 0, + Some(Value::String(s)) => s == "1" || s.eq_ignore_ascii_case("true"), + _ => false, + } +} + +fn str_of(obj: &Map, key: &str) -> String { + obj.get(key) + .and_then(Value::as_str) + .unwrap_or("") + .to_string() +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn model() -> Value { + json!([ + { + "table": "t_main", "tableName": "主表", "typeId": "1", + "fields": [ + {"field":"F_Id","columnName":null,"fieldName":"主键","dataType":"varchar", + "dataLength":"50","primaryKey":1,"allowNull":0}, + {"field":"F_Title","columnName":null,"fieldName":"标题","dataType":"varchar", + "dataLength":"200","primaryKey":0,"allowNull":1}, + {"field":"F_Amount","columnName":"f_amount","fieldName":"金额","dataType":"numeric", + "dataLength":"","primaryKey":0,"allowNull":1} + ] + }, + { + "table": "t_child", "tableName": "子表", "typeId": "0", + "fields": [ + {"field":"F_Item","columnName":null,"fieldName":"项目","dataType":"varchar", + "dataLength":"100","primaryKey":0,"allowNull":1} + ] + } + ]) + } + + #[test] + fn parses_tables_and_flags() { + let m = ModelSchema::parse(&model()).unwrap(); + assert_eq!(m.tables.len(), 2); + assert_eq!(m.main_table().unwrap().table, "t_main"); + assert_eq!(m.sub_tables().len(), 1); + assert!(m.main_table().unwrap().is_main()); + } + + /// 🔴 `columnName` 为 null 时必须从 `field` 推导 —— 实测数据大量如此。 + #[test] + fn resolves_column_name_when_null() { + let m = ModelSchema::parse(&model()).unwrap(); + let t = m.main_table().unwrap(); + assert_eq!(t.column_names(), vec!["f_id", "f_title", "f_amount"]); + assert_eq!( + t.column_by_field("F_Title").unwrap().resolved_column().as_deref(), + Some("f_title") + ); + } + + /// 官方给了 `columnName` 时以它为准(可能与推导结果不同)。 + #[test] + fn prefers_explicit_column_name() { + let m = ModelSchema::parse(&model()).unwrap(); + let t = m.main_table().unwrap(); + let c = t.column_by_field("F_Amount").unwrap(); + assert_eq!(c.column_name.as_deref(), Some("f_amount")); + assert_eq!(c.resolved_column().as_deref(), Some("f_amount")); + } + + #[test] + fn primary_keys_are_reported() { + let m = ModelSchema::parse(&model()).unwrap(); + assert_eq!(m.main_table().unwrap().primary_keys(), vec!["f_id"]); + } + + #[test] + fn rejects_wrong_shapes() { + assert_eq!(ModelSchema::parse(&json!({})).unwrap_err(), ModelError::NotAnArray); + assert_eq!(ModelSchema::parse(&json!([])).unwrap_err(), ModelError::Empty); + } + + /// 主表可能缺失(用户只建了子表)—— 调用方要能处理。 + #[test] + fn missing_main_table_is_none_not_panic() { + let m = ModelSchema::parse(&json!([ + {"table":"t_child","typeId":"0","fields":[]} + ])) + .unwrap(); + assert!(m.main_table().is_none()); + assert_eq!(m.sub_tables().len(), 1); + } + + /// 布尔字段可能是 0/1、"1"、true —— 三种都要认。 + #[test] + fn truthy_accepts_three_encodings() { + assert!(truthy(Some(&json!(1)))); + assert!(truthy(Some(&json!("1")))); + assert!(truthy(Some(&json!(true)))); + assert!(!truthy(Some(&json!(0)))); + assert!(!truthy(Some(&json!("0")))); + assert!(!truthy(None)); + } + + #[test] + fn raw_is_preserved() { + let v = model(); + let m = ModelSchema::parse(&v).unwrap(); + assert_eq!(m.raw, v); + } +} diff --git a/crates/sspf-lowcode/src/validate.rs b/crates/sspf-lowcode/src/validate.rs new file mode 100644 index 0000000..7ea7c65 --- /dev/null +++ b/crates/sspf-lowcode/src/validate.rs @@ -0,0 +1,491 @@ +//! validate —— 表单 ↔ 模型**一致性校验**。 +//! +//! ## 这是 P2 的验收核心 +//! +//! PLAN 的 P2 出口是「基线平台导出的表单 JSON,不改一个字段能在 SSPF 上渲染 + 存取」。 +//! 「能存取」的前提是**表单声明的字段,表里真有那些列** —— 这个前提在真实数据里 +//! 经常不成立(改名不同步、删列没删控件、子表指向不存在的表)。 +//! +//! 如果不校验就上动态 CRUD,症状是:**插入时少一列、查询时 sql 报错**, +//! 而错误信息是数据库给的(`column "f_xxx" does not exist`),AI 根本不知道该改哪。 +//! +//! ⇒ 校验器把「数据库层的报错」提前成「设计态的明确诊断」。 +//! +//! ## 诊断码表 +//! +//! | 码 | 级别 | 含义 | +//! |---|---|---| +//! | `TABLE_NOT_IN_MODEL` | error | 表单引用的表没在 `f_tables_data` 里声明 | +//! | `COLUMN_NOT_IN_TABLE` | error | 表单字段在主表列里找不到对应列 | +//! | `SUBTABLE_COLUMN_MISSING` | error | 子表字段在子表列里找不到 | +//! | `REQUIRED_WITHOUT_COLUMN` | error | 必填字段没有对应列(必然存不进去) | +//! | `NO_MAIN_TABLE` | error | `f_tables_data` 里没有主表(`typeId=1`) | +//! | `UNKNOWN_WIDGET` | warn | 未知控件(已降级为文本) | +//! | `EMPTY_DATA_FIELDS` | warn | 表单没有任何数据字段 | +//! | `REQUIRED_NULLABLE` | warn | 必填字段对应的列允许 NULL(约束只在应用层) | +//! | `DISABLED_WIDGET_HAS_VALUE` | warn | 系统生成字段被设计成可编辑 | +//! +//! ## 为什么不用 error 就拦死 +//! +//! `warn` 不阻断:未知控件降级后仍能读写,人工再修。 +//! `error` 也不直接阻断存取 —— 有些库确实「设计稿先进、表后建」。 +//! 但 `form.validate` 会把 error 明确报出来,让 AI 先修再存。 + +use serde_json::{json, Value}; + +use crate::form::FormSchema; +use crate::model::ModelSchema; +use crate::widget::WidgetKind; + +/// 诊断级别。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Severity { + /// 会导致存取失败或写坏数据。 + Error, + /// 能跑,但结果可能不符合预期。 + Warn, + /// 纯提示。 + Info, +} + +impl Severity { + /// 稳定字符串。 + pub fn as_str(self) -> &'static str { + match self { + Severity::Error => "error", + Severity::Warn => "warn", + Severity::Info => "info", + } + } +} + +/// 一条诊断。 +#[derive(Debug, Clone, PartialEq)] +pub struct Diagnostic { + /// 机器可读码。 + pub code: &'static str, + /// 级别。 + pub severity: Severity, + /// 人话说明(含定位信息)。 + pub message: String, + /// 出问题的位置(字段名 / 表名 / JSON 路径)。 + pub path: String, +} + +impl Diagnostic { + fn new(code: &'static str, severity: Severity, path: impl Into, message: impl Into) -> Self { + Self { + code, + severity, + path: path.into(), + message: message.into(), + } + } +} + +/// 校验报告。 +#[derive(Debug, Clone, Default)] +pub struct Report { + /// 全部诊断(按发现顺序)。 + pub diagnostics: Vec, +} + +impl Report { + /// 是否没有任何 error(warn 不影响)。 + pub fn ok(&self) -> bool { + !self + .diagnostics + .iter() + .any(|d| d.severity == Severity::Error) + } + + /// 错误条数。 + pub fn error_count(&self) -> usize { + self.diagnostics + .iter() + .filter(|d| d.severity == Severity::Error) + .count() + } + + /// 警告条数。 + pub fn warn_count(&self) -> usize { + self.diagnostics + .iter() + .filter(|d| d.severity == Severity::Warn) + .count() + } + + /// 序列化成 MCP 工具的输出形状。 + pub fn to_json(&self) -> Value { + json!({ + "ok": self.ok(), + "errorCount": self.error_count(), + "warnCount": self.warn_count(), + "diagnostics": self.diagnostics.iter().map(|d| json!({ + "code": d.code, + "severity": d.severity.as_str(), + "path": d.path, + "message": d.message, + })).collect::>(), + }) + } + + fn push(&mut self, d: Diagnostic) { + self.diagnostics.push(d); + } +} + +/// 校验「表单定义」与「模型定义」是否自洽。 +pub fn validate(form: &FormSchema, model: &ModelSchema) -> Report { + let mut r = Report::default(); + + // ---- 1) 主表必须存在 ---- + let Some(main) = model.main_table() else { + r.push(Diagnostic::new( + "NO_MAIN_TABLE", + Severity::Error, + "f_tables_data", + "模型里没有主表(typeId=1)—— 动态 CRUD 不知道该写哪张表", + )); + return r; + }; + + // ---- 2) 表单引用的每张表都要有定义 ---- + for t in form.table_names() { + if model.table(&t).is_none() { + r.push(Diagnostic::new( + "TABLE_NOT_IN_MODEL", + Severity::Error, + format!("table:{t}"), + format!( + "表单引用了表 `{t}`,但 f_tables_data 里没有它。\ + 典型原因:控件上的 tableName 改了但模型没同步" + ), + )); + } + } + + // ---- 3) 主表字段 ↔ 主表列 ---- + let main_fields = form.main_fields(); + if main_fields.is_empty() { + r.push(Diagnostic::new( + "EMPTY_DATA_FIELDS", + Severity::Warn, + "fields", + "表单没有任何数据字段(全是布局/子表)—— 这个表单存不了主表数据", + )); + } + + for f in &main_fields { + let Some(col) = f.column_name() else { + // 系统生成字段可能没有 __vModel__,跳过(它们由后端填) + if f.widget != WidgetKind::SystemGenerated { + r.push(Diagnostic::new( + "COLUMN_NOT_IN_TABLE", + Severity::Error, + format!("field:{}", f.label), + format!( + "字段「{}」({})没有 __vModel__,无法映射到列", + f.label, f.jnpf_key + ), + )); + } + continue; + }; + + let found = main.column_by_name(&col); + if found.is_none() { + let code = if f.required { + "REQUIRED_WITHOUT_COLUMN" + } else { + "COLUMN_NOT_IN_TABLE" + }; + r.push(Diagnostic::new( + code, + Severity::Error, + format!("field:{}", f.v_model), + format!( + "字段「{}」的 `{}` 映射到列 `{}`,但主表 `{}` 没有这一列。\ + 现有列:{}", + f.label, + f.v_model, + col, + main.table, + preview(&main.column_names()) + ), + )); + continue; + } + + // ---- 3b) 必填但列允许 NULL ---- + if f.required { + if let Some(c) = found { + if c.allow_null { + r.push(Diagnostic::new( + "REQUIRED_NULLABLE", + Severity::Warn, + format!("field:{}", f.v_model), + format!( + "字段「{}」设计为必填,但列 `{col}` 允许 NULL —— \ + 约束只在应用层生效,直接写库仍可绕过", + f.label + ), + )); + } + } + } + } + + // ---- 4) 子表字段 ↔ 子表列 ---- + for sub in form.sub_tables() { + let Some(table_name) = sub.table_name.as_deref().filter(|s| !s.is_empty()) else { + r.push(Diagnostic::new( + "TABLE_NOT_IN_MODEL", + Severity::Error, + format!("subtable:{}", sub.label), + format!("子表「{}」没有 tableName —— 不知道数据该进哪张表", sub.label), + )); + continue; + }; + let Some(t) = model.table(table_name) else { + // 已在第 2 步报过 TABLE_NOT_IN_MODEL,这里不重复 + continue; + }; + for c in &sub.children { + if !c.widget.occupies_column() { + continue; + } + let Some(col) = c.column_name() else { + continue; + }; + if t.column_by_name(&col).is_none() { + r.push(Diagnostic::new( + "SUBTABLE_COLUMN_MISSING", + Severity::Error, + format!("subtable:{}:{}", table_name, c.v_model), + format!( + "子表「{}」的字段「{}」映射到列 `{}`,但表 `{}` 没有这一列", + sub.label, c.label, col, table_name + ), + )); + } + } + } + + // ---- 5) 未知控件(降级警告)---- + let unknown = form.unknown_widgets(); + if !unknown.is_empty() { + let mut keys: Vec<&str> = unknown.iter().map(|n| n.jnpf_key.as_str()).collect(); + keys.sort_unstable(); + keys.dedup(); + r.push(Diagnostic::new( + "UNKNOWN_WIDGET", + Severity::Warn, + "fields", + format!( + "{} 个未知控件({})已降级为文本 —— 能读写,但控件语义丢失;\ + 补齐 crates/sspf-lowcode/src/widget.rs 的 classify() 可精确支持", + unknown.len(), + keys.join(", ") + ), + )); + } + + // ---- 6) 系统生成字段被设计成可编辑 ---- + for n in form.all_nodes() { + if n.widget == WidgetKind::SystemGenerated && !n.no_show && n.required { + r.push(Diagnostic::new( + "DISABLED_WIDGET_HAS_VALUE", + Severity::Warn, + format!("field:{}", n.v_model), + format!( + "「{}」是系统生成控件({})却被标成必填 —— \ + 动态 CRUD 不会接收它的入参,必填校验会永远失败", + n.label, n.jnpf_key + ), + )); + } + } + + r +} + +/// 列名预览(最多 8 个,避免诊断信息过长)。 +fn preview(cols: &[String]) -> String { + if cols.is_empty() { + return "(无列)".to_string(); + } + let mut shown: Vec<&str> = cols.iter().take(8).map(String::as_str).collect(); + let more = cols.len().saturating_sub(8); + let mut s = shown.join(", "); + shown.clear(); + if more > 0 { + s.push_str(&format!(" …(还有 {more} 列)")); + } + s +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn model() -> ModelSchema { + ModelSchema::parse(&json!([ + { + "table": "t_main", "tableName": "主表", "typeId": "1", + "fields": [ + {"field":"F_Id","fieldName":"主键","dataType":"varchar","primaryKey":1,"allowNull":0}, + {"field":"F_Title","fieldName":"标题","dataType":"varchar","allowNull":0}, + {"field":"F_Memo","fieldName":"备注","dataType":"varchar","allowNull":1} + ] + }, + { + "table": "t_child", "tableName": "子表", "typeId": "0", + "fields": [{"field":"F_Item","fieldName":"项目","dataType":"varchar","allowNull":1}] + } + ])) + .unwrap() + } + + fn form_ok() -> FormSchema { + FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [ + {"__config__":{"jnpfKey":"input","tableName":"t_main","label":"标题","required":true}, + "__vModel__":"F_Title"}, + {"__config__":{"jnpfKey":"textarea","tableName":"t_main","label":"备注"}, + "__vModel__":"F_Memo"}, + {"__config__":{"jnpfKey":"table","layout":"rowFormItem","tableName":"t_child","label":"明细"}, + "__vModel__":"tableField", + "children":[{"__config__":{"jnpfKey":"input","tableName":"t_child","label":"项目"}, + "__vModel__":"F_Item"}]} + ] + })) + .unwrap() + } + + #[test] + fn clean_form_has_no_errors() { + let r = validate(&form_ok(), &model()); + assert!(r.ok(), "不该有 error: {:?}", r.diagnostics); + assert_eq!(r.error_count(), 0); + } + + /// 最常见的问题:控件改了名,模型没同步 ⇒ 列不存在。 + #[test] + fn field_without_column_is_error_with_existing_columns() { + let f = FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [{"__config__":{"jnpfKey":"input","tableName":"t_main","label":"不存在的字段"}, + "__vModel__":"F_Ghost"}] + })) + .unwrap(); + let r = validate(&f, &model()); + assert!(!r.ok()); + let d = r + .diagnostics + .iter() + .find(|d| d.code == "COLUMN_NOT_IN_TABLE") + .expect("应报 COLUMN_NOT_IN_TABLE"); + assert!(d.message.contains("f_ghost")); + assert!(d.message.contains("f_title"), "要把现有列列出来,AI 才知道怎么改"); + } + + /// 必填字段没列 → 必须用更精确的码(REQUIRED_WITHOUT_COLUMN)。 + #[test] + fn required_field_without_column_uses_specific_code() { + let f = FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [{"__config__":{"jnpfKey":"input","tableName":"t_main","label":"必填幽灵","required":true}, + "__vModel__":"F_Ghost"}] + })) + .unwrap(); + let r = validate(&f, &model()); + assert!(r + .diagnostics + .iter() + .any(|d| d.code == "REQUIRED_WITHOUT_COLUMN")); + } + + #[test] + fn subtable_column_missing_is_reported() { + let f = FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [ + {"__config__":{"jnpfKey":"input","tableName":"t_main","label":"标题"},"__vModel__":"F_Title"}, + {"__config__":{"jnpfKey":"table","layout":"rowFormItem","tableName":"t_child","label":"明细"}, + "__vModel__":"tableField", + "children":[{"__config__":{"jnpfKey":"input","tableName":"t_child","label":"幽灵"}, + "__vModel__":"F_Nope"}]} + ] + })) + .unwrap(); + let r = validate(&f, &model()); + assert!(r + .diagnostics + .iter() + .any(|d| d.code == "SUBTABLE_COLUMN_MISSING")); + } + + #[test] + fn table_missing_from_model_is_reported() { + let f = FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [{"__config__":{"jnpfKey":"input","tableName":"t_other","label":"x"},"__vModel__":"F_X"}] + })) + .unwrap(); + let r = validate(&f, &model()); + assert!(r.diagnostics.iter().any(|d| d.code == "TABLE_NOT_IN_MODEL")); + } + + #[test] + fn no_main_table_is_reported_once_and_stops() { + let m = ModelSchema::parse(&json!([ + {"table":"t_child","typeId":"0","fields":[]} + ])) + .unwrap(); + let r = validate(&form_ok(), &m); + assert!(!r.ok()); + assert_eq!(r.error_count(), 1, "只报一次,不继续刷错"); + assert_eq!(r.diagnostics[0].code, "NO_MAIN_TABLE"); + } + + /// warn 不算失败 —— 未知控件降级后仍可用。 + #[test] + fn unknown_widget_is_warn_not_error() { + let f = FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [{"__config__":{"jnpfKey":"futureWidget","tableName":"t_main","label":"x"}, + "__vModel__":"F_Title"}] + })) + .unwrap(); + let r = validate(&f, &model()); + assert!(r.ok(), "warn 不该让 ok=false"); + assert_eq!(r.warn_count(), 1); + assert_eq!(r.diagnostics[0].code, "UNKNOWN_WIDGET"); + } + + #[test] + fn required_on_nullable_column_is_warn() { + // F_Memo 允许 NULL,但被设成必填 + let f = FormSchema::parse(&json!({ + "formRef": "elForm", + "fields": [{"__config__":{"jnpfKey":"input","tableName":"t_main","label":"备注","required":true}, + "__vModel__":"F_Memo"}] + })) + .unwrap(); + let r = validate(&f, &model()); + assert!(r.ok()); + assert!(r.diagnostics.iter().any(|d| d.code == "REQUIRED_NULLABLE")); + } + + #[test] + fn report_serializes_to_tool_shape() { + let r = validate(&form_ok(), &model()); + let j = r.to_json(); + assert_eq!(j["ok"], true); + assert_eq!(j["errorCount"], 0); + assert!(j["diagnostics"].is_array()); + } +} diff --git a/crates/sspf-lowcode/src/widget.rs b/crates/sspf-lowcode/src/widget.rs new file mode 100644 index 0000000..84b100d --- /dev/null +++ b/crates/sspf-lowcode/src/widget.rs @@ -0,0 +1,253 @@ +//! widget —— `jnpfKey` 控件分类表:**这张表决定数据怎么存**。 +//! +//! ## 为什么需要它 +//! +//! baseline 的表单 JSON 里有 **54 种** `jnpfKey`(实测 71 张表单统计), +//! 但对「存数据」来说它们只分十来类: +//! +//! | 类别 | 举例 | 存成什么 | 接收入参 | +//! |---|---|---|---| +//! | 文本 | `input` `textarea` `editor` | 字符串 | ✅ | +//! | 数值 | `inputNumber` `calculate` `rate` | 数字 | 视情况(`calculate` 只读) | +//! | 日期时间 | `datePicker` `timePicker` `createTime` | 时间戳 / 字符串 | 视情况 | +//! | 枚举 | `select` `radio` `checkbox` `switch` | 字符串 / 整数 | ✅ | +//! | 实体引用 | `userSelect` `organizeSelect` `depSelect` | 对象 id | ✅(存 id) | +//! | 系统生成 | `billRule` `createUser` `currOrganize` | — | ❌ 后端自动填 | +//! | 子表 | `table` `tableGrid` | 独立物理表 | ❌ 走子表接口 | +//! | 附件 | `uploadFile` `uploadImg` | JSON 字符串(URL 列表) | ✅ | +//! | 布局 | `groupTitle` `divider` `tabItem` `rowFormItem` | 不占列 | ❌ | +//! +//! 🔴 **分类错了就是数据错**:把 `billRule`(单据号,系统生成)当普通文本接收, +//! 会把用户传的任意字符串写进单号列,破坏业务编号规则; +//! 把 `uploadFile` 当纯文本,前端 `JSON.parse` 会炸。 +//! +//! ## 未知控件怎么办 +//! +//! 按 PLAN §P2 的策略:**降级为文本并给出警告**,不阻断。 +//! 理由:新控件(官方每版都在加)如果直接拒,会让整张表单无法存取; +//! 降级成文本至少能读能写,人工再修。但警告必须回报给 AI —— 见 +//! [`WidgetKind::Unknown`]。 + +/// 控件类别 —— 决定「怎么存、能不能接收入参」。 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum WidgetKind { + /// 文本(`input` / `textarea` / `editor` / `text` …)。 + Text, + /// 数值(`inputNumber` / `rate` / `slider` …)。 + Number, + /// 日期时间(`datePicker` / `timePicker` …)。 + DateTime, + /// 枚举选择(`select` / `radio` / `checkbox` / `switch` / `cascader` …)。 + Enum, + /// 实体引用(`userSelect` / `organizeSelect` / `depSelect` / `posSelect` …)—— + /// 值存的是**对象 id**,不是名称。 + EntityRef, + /// 系统自动生成(`billRule` / `createUser` / `createTime` / `currOrganize` …)—— + /// **不接收入参**,由后端写入。 + SystemGenerated, + /// 子表容器(`table` / `tableGrid` …)—— 数据在独立物理表,不占主表列。 + SubTable, + /// 附件(`uploadFile` / `uploadImg`)—— 存 URL 列表的 JSON 字符串。 + Attachment, + /// 布局(`groupTitle` / `divider` / `tabItem` …)—— 不占任何列。 + Layout, + /// 计算字段(`calculate`)—— 只读,由公式算出。 + Computed, + /// 未知控件 —— 降级为文本并警告。 + Unknown, +} + +impl WidgetKind { + /// 该类别是否占一个**物理列**(决定要不要做列映射校验)。 + pub fn occupies_column(self) -> bool { + !matches!(self, WidgetKind::Layout | WidgetKind::SubTable) + } + + /// 该类别是否允许从请求入参接收值。 + /// + /// 🔴 `SystemGenerated` / `Computed` / `SubTable` / `Layout` 一律拒绝 —— + /// 让入参覆盖单号、创建人、计算结果,是最常见的「数据被写坏」来源。 + pub fn accepts_input(self) -> bool { + matches!( + self, + WidgetKind::Text + | WidgetKind::Number + | WidgetKind::DateTime + | WidgetKind::Enum + | WidgetKind::EntityRef + | WidgetKind::Attachment + ) + } + + /// 稳定字符串(用于 JSON 输出与诊断信息)。 + pub fn as_str(self) -> &'static str { + match self { + WidgetKind::Text => "text", + WidgetKind::Number => "number", + WidgetKind::DateTime => "dateTime", + WidgetKind::Enum => "enum", + WidgetKind::EntityRef => "entityRef", + WidgetKind::SystemGenerated => "systemGenerated", + WidgetKind::SubTable => "subTable", + WidgetKind::Attachment => "attachment", + WidgetKind::Layout => "layout", + WidgetKind::Computed => "computed", + WidgetKind::Unknown => "unknown", + } + } +} + +/// `jnpfKey` → 类别。 +/// +/// 映射取自实测分布(71 张真表单 / 54 种控件,覆盖率见测试)。 +/// **新增控件时改这里,别改调用方** —— 保持分类逻辑的单点。 +pub fn classify(jnpf_key: &str) -> WidgetKind { + match jnpf_key { + // ---- 文本 ---- + "input" | "textarea" | "editor" | "text" | "link" | "colorPicker" | "inputColor" + | "signature" | "location" | "address" | "barcode" | "qrcode" | "map" | "idNumber" + | "phoneNumber" | "email" | "url" | "richText" | "codeEditor" => WidgetKind::Text, + + // ---- 数值 ---- + "inputNumber" | "rate" | "slider" | "money" | "percent" => WidgetKind::Number, + + // ---- 日期时间 ---- + "datePicker" | "timePicker" | "dateRange" | "timeRange" | "dateCalculate" => { + WidgetKind::DateTime + } + + // ---- 枚举 ---- + "select" | "radio" | "checkbox" | "switch" | "cascader" | "treeSelect" | "multiSelect" + | "autoComplete" | "selectMultiple" | "checkboxGroup" | "treeSelectMultiple" => { + WidgetKind::Enum + } + + // ---- 实体引用(值 = 对象 id)---- + "userSelect" | "organizeSelect" | "depSelect" | "posSelect" | "roleSelect" + | "groupSelect" | "usersSelect" | "relationForm" | "popupSelect" | "popupTableSelect" + | "relationFormAttr" | "popupAttr" => WidgetKind::EntityRef, + + // ---- 系统自动生成(不接收入参)---- + "billRule" | "createUser" | "createTime" | "modifyUser" | "modifyTime" | "currOrganize" + | "currPosition" | "lastModifyUser" | "lastModifyTime" | "createUserId" + | "modifyUserId" | "tenantId" => WidgetKind::SystemGenerated, + + // ---- 子表 ---- + "table" | "tableGrid" | "tableGridTd" | "childTable" => WidgetKind::SubTable, + + // ---- 附件 ---- + "uploadFile" | "uploadImg" | "uploadFileSingle" | "uploadImgSingle" | "imgupload" + | "fileupload" => WidgetKind::Attachment, + + // ---- 布局(不占列)---- + "groupTitle" | "divider" | "tabItem" | "tab" | "row" | "collapse" | "collapseItem" + | "steps" | "stepsItem" | "card" | "alert" | "button" | "textTitle" | "title" => { + WidgetKind::Layout + } + + // ---- 计算字段(只读)---- + "calculate" => WidgetKind::Computed, + + _ => WidgetKind::Unknown, + } +} + +/// 给未知控件用的人话提示(会进诊断信息)。 +pub fn unknown_hint(jnpf_key: &str) -> String { + format!( + "未知控件 `{jnpf_key}`(按文本降级处理)。\ + 若它其实是布局/系统字段,存取会多写一列空值;\ + 要精确支持,把 jnpf_key 补进 crates/sspf-lowcode/src/widget.rs 的 classify()" + ) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 实测 top 12 控件必须全部被识别(覆盖率是硬指标,不是感觉)。 + #[test] + fn top_widgets_are_all_classified() { + // 来自 71 张真表单的分布统计 + let top = [ + ("input", WidgetKind::Text, 267), + ("inputNumber", WidgetKind::Number, 88), + ("select", WidgetKind::Enum, 71), + ("datePicker", WidgetKind::DateTime, 71), + ("textarea", WidgetKind::Text, 42), + ("userSelect", WidgetKind::EntityRef, 36), + ("table", WidgetKind::SubTable, 28), + ("organizeSelect", WidgetKind::EntityRef, 25), + ("billRule", WidgetKind::SystemGenerated, 18), + ("radio", WidgetKind::Enum, 18), + ("groupTitle", WidgetKind::Layout, 14), + ("uploadFile", WidgetKind::Attachment, 12), + ]; + let mut covered = 0; + let mut total = 0; + for (key, want, count) in top { + assert_eq!(classify(key), want, "{key} 分类错了"); + covered += count; + total += count; + } + assert_eq!(covered, total); + println!("top 12 控件全部识别,共 {covered} 个实例"); + } + + #[test] + fn system_generated_refuses_input() { + for k in ["billRule", "createUser", "createTime", "currOrganize"] { + let w = classify(k); + assert_eq!(w, WidgetKind::SystemGenerated, "{k}"); + assert!(!w.accepts_input(), "{k} 不该接收入参"); + assert!(w.occupies_column(), "{k} 占一列(后端要写)"); + } + } + + #[test] + fn layout_occupies_no_column() { + for k in ["groupTitle", "divider", "tabItem"] { + let w = classify(k); + assert_eq!(w, WidgetKind::Layout, "{k}"); + assert!(!w.occupies_column(), "{k} 不该占列"); + } + } + + #[test] + fn sub_table_is_not_a_column() { + let w = classify("table"); + assert_eq!(w, WidgetKind::SubTable); + assert!(!w.occupies_column()); + assert!(!w.accepts_input()); + } + + #[test] + fn unknown_falls_back_to_text_with_hint() { + assert_eq!(classify("someFutureWidget"), WidgetKind::Unknown); + let h = unknown_hint("someFutureWidget"); + assert!(h.contains("someFutureWidget")); + assert!(h.contains("widget.rs"), "提示要指明改哪里"); + } + + /// 类别字符串必须唯一且稳定(它们会出现在 JSON 输出里,改成对账就漂了)。 + #[test] + fn kind_names_are_unique() { + let all = [ + WidgetKind::Text, + WidgetKind::Number, + WidgetKind::DateTime, + WidgetKind::Enum, + WidgetKind::EntityRef, + WidgetKind::SystemGenerated, + WidgetKind::SubTable, + WidgetKind::Attachment, + WidgetKind::Layout, + WidgetKind::Computed, + WidgetKind::Unknown, + ]; + let mut seen = std::collections::HashSet::new(); + for k in all { + assert!(seen.insert(k.as_str()), "类别名重复: {}", k.as_str()); + } + } +} diff --git a/crates/sspf-lowcode/tests/fixtures/sample_form.json b/crates/sspf-lowcode/tests/fixtures/sample_form.json new file mode 100644 index 0000000..0e62203 --- /dev/null +++ b/crates/sspf-lowcode/tests/fixtures/sample_form.json @@ -0,0 +1,751 @@ +{ + "formRef": "formRef", + "formModel": "dataForm", + "size": "default", + "labelPosition": "right", + "labelWidth": 100, + "labelSuffix": "", + "formRules": "rules", + "popupType": "general", + "generalWidth": "1000px", + "fullScreenWidth": "100%", + "drawerWidth": "600px", + "gutter": 15, + "disabled": false, + "span": 24, + "colon": false, + "hasCancelBtn": true, + "cancelButtonText": "取消", + "cancelButtonTextI18nCode": "common.cancelText", + "hasConfirmBtn": true, + "confirmButtonText": "确定", + "confirmButtonTextI18nCode": "common.okText", + "hasConfirmAndAddBtn": true, + "hasPrintBtn": false, + "printButtonText": "打印", + "printButtonTextI18nCode": "common.printText", + "customBtns": [], + "appCustomBtns": [], + "primaryKeyPolicy": 1, + "concurrencyLock": false, + "logicalDelete": false, + "dataLog": false, + "useBusinessKey": false, + "businessKeyList": [], + "businessKeyTip": "数据已存在,请勿重复提交!", + "printId": "", + "formStyle": "", + "classNames": [], + "className": [], + "classJson": "", + "detailExtraList": [], + "funcs": { + "beforeSubmit": "({ formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n return new Promise((resolve, reject) => {\n // 在此编写代码\n \n // 继续执行\n resolve()\n })\n}", + "onLoad": "({ formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "afterSubmit": "({ formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + }, + "fields": [ + { + "__config__": { + "formId": 101, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "billRule", + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "rule": "rukudanhao", + "className": [], + "label": "楼宇号", + "trigger": "change", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916533424, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-documents", + "ruleName": "入库单号", + "tag": "JnpfInput", + "span": 12, + "ruleType": 1, + "ruleConfig": { + "prefixList": [], + "type": 1, + "dateFormat": "YYYY", + "digit": null, + "startNumber": "", + "randomDigit": 16, + "randomType": 1, + "suffixList": [] + } + }, + "readonly": true, + "__vModel__": "F_Building", + "style": { + "width": "100%" + }, + "placeholder": "系统自动生成" + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 102, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "房间号", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916557528, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "tag": "JnpfInput", + "regList": [], + "span": 12 + }, + "readonly": false, + "__vModel__": "F_Room", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 103, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "公司名称", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916580722, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "tag": "JnpfInput", + "regList": [], + "span": 12 + }, + "readonly": false, + "__vModel__": "F_Company_name", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 104, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "对接人", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916581187, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "tag": "JnpfInput", + "regList": [], + "span": 12 + }, + "readonly": false, + "__vModel__": "F_Userid", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 105, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "联系方式", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916609582, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Phone", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 106, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "职务", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916619222, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Ost", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "showSummary": 0, + "actionText": "添加", + "tableConf": {}, + "defaultValue": [], + "footerBtnsList": [ + { + "btnIcon": "icon-ym icon-ym-btn-add", + "show": true, + "label": "添加", + "btnType": "primary", + "value": "add" + }, + { + "btnIcon": "icon-ym icon-ym-btn-clearn", + "showConfirm": true, + "show": true, + "label": "批量删除", + "btnType": "danger", + "value": "batchRemove" + } + ], + "addTableConf": { + "popupType": "dialog", + "hasPage": true, + "popupTitle": "选择数据", + "pageSize": 20, + "columnOptions": [], + "interfaceId": "", + "interfaceName": "", + "relationOptions": [], + "templateJson": [], + "popupWidth": "800px" + }, + "columnBtnsList": [ + { + "btnIcon": "icon-ym icon-ym-btn-edit", + "show": true, + "label": "复制", + "btnType": "primary", + "value": "copy" + }, + { + "btnIcon": "icon-ym icon-ym-btn-clearn", + "showConfirm": true, + "show": true, + "label": "删除", + "btnType": "danger", + "value": "remove" + } + ], + "summaryField": [], + "showDeleteBtn": true, + "addType": 0, + "__config__": { + "formId": 107, + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "table", + "defaultValue": [], + "noShow": false, + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "添加明细", + "type": "table", + "showLabel": false, + "tableName": "test_details", + "renderKey": 1693916635901, + "layout": "rowFormItem", + "tagIcon": "icon-ym icon-ym-generator-table", + "children": [ + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 108, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "缴费月份", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916679090, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Month", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 109, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "房租", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916698892, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Rent", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 110, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "水费", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916709404, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Water_rent", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 111, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "电费", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916719125, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Powerrate", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 112, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "物业费", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916726876, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Property", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 113, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "垃圾费", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916738956, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Cleaning", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 114, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "排污费", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916749773, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Pollutant", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + }, + { + "clearable": true, + "suffixIcon": "", + "addonAfter": "", + "__config__": { + "formId": 115, + "relationTable": "test_details", + "visibility": [ + "pc", + "app" + ], + "jnpfKey": "input", + "noShow": false, + "parentVModel": "tableField107", + "tipLabel": "", + "dragDisabled": false, + "className": [], + "label": "累计应收费用", + "trigger": "blur", + "showLabel": true, + "required": false, + "tableName": "test_receivable", + "renderKey": 1693916759950, + "layout": "colFormItem", + "tagIcon": "icon-ym icon-ym-generator-input", + "isSubTable": true, + "tag": "JnpfInput", + "regList": [], + "span": 24 + }, + "readonly": false, + "__vModel__": "F_Totalbilling", + "showPassword": false, + "style": { + "width": "100%" + }, + "disabled": false, + "placeholder": "请输入", + "prefixIcon": "", + "addonBefore": "", + "on": { + "change": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}", + "blur": "({ data, formData, setFormData, setShowOrHide, setRequired, setDisabled, onlineUtils }) => {\n // 在此编写代码\n \n}" + } + } + ], + "showTitle": true, + "complexHeaderList": [], + "tag": "JnpfInputTable", + "componentName": "table107", + "span": 24 + }, + "showAddBtn": true, + "__vModel__": "tableField107", + "disabled": false, + "layoutType": "table" + } + ], + "idGlobal": 115, + "formBtns": false, + "confirmAndAddText": "确定并继续操作" +} \ No newline at end of file diff --git a/crates/sspf-lowcode/tests/fixtures/sample_model.json b/crates/sspf-lowcode/tests/fixtures/sample_model.json new file mode 100644 index 0000000..9f29cc7 --- /dev/null +++ b/crates/sspf-lowcode/tests/fixtures/sample_model.json @@ -0,0 +1,451 @@ +[ + { + "relationTable": "", + "tableField": "", + "typeId": "1", + "fields": [ + { + "allowNull": 0, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Id", + "fieldName": "主键", + "identity": 0, + "primaryKey": 1 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "100", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Building", + "fieldName": "楼宇号", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "100", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Room", + "fieldName": "房间号", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Company_name", + "fieldName": "公司名称", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Userid", + "fieldName": "对接人", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Phone", + "fieldName": "联系方式", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Ost", + "fieldName": "职务", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "bigint", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Sort_Code", + "fieldName": "排序", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "int", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_EnabledMark", + "fieldName": "有效标志", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "datetime", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_CreatorTime", + "fieldName": "创建时间", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_CreatorUserId", + "fieldName": "创建用户", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "datetime", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_LastModifyTime", + "fieldName": "修改时间", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_LastModifyUserId", + "fieldName": "修改用户", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 0, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_tenant_id", + "fieldName": "租户id", + "identity": 0, + "primaryKey": 1 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "int", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_version", + "fieldName": "乐观锁", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_flowtaskid", + "fieldName": "流程任务主键", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_flow_id", + "fieldName": "流程id", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_flow_task_id", + "fieldName": "流程任务主键", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "int", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_inte_assistant", + "fieldName": "集成助手数据标识", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "int", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_flow_state", + "fieldName": "流程任务状态", + "identity": 0, + "primaryKey": 0 + } + ], + "relationField": "", + "table": "test_receivable", + "tableName": "应收费用主表" + }, + { + "relationTable": "test_receivable", + "tableField": "F_Receivableid", + "typeId": "0", + "fields": [ + { + "allowNull": 0, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Id", + "fieldName": "主键", + "identity": 0, + "primaryKey": 1 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Receivableid", + "fieldName": "主表主键", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "200", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Month", + "fieldName": "缴费月份", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Rent", + "fieldName": "房租", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Water_rent", + "fieldName": "水费", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Powerrate", + "fieldName": "电费", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Property", + "fieldName": "物业费", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Cleaning", + "fieldName": "垃圾费", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Pollutant", + "fieldName": "排污费", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "18,2", + "dataType": "decimal", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_Totalbilling", + "fieldName": "累计应收费用", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": null, + "dataType": "datetime", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_CreatorTime", + "fieldName": "创建时间", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 1, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "F_CreatorUserId", + "fieldName": "创建用户", + "identity": 0, + "primaryKey": 0 + }, + { + "allowNull": 0, + "autoIncrement": 0, + "columnName": null, + "dataLength": "50", + "dataType": "varchar", + "dataTypeName": null, + "dataTypeReal": null, + "field": "f_tenant_id", + "fieldName": "租户id", + "identity": 0, + "primaryKey": 1 + } + ], + "relationField": "F_Id", + "table": "test_details", + "tableName": "应收费用明细表" + } +] \ No newline at end of file diff --git a/crates/sspf-lowcode/tests/real_sample.rs b/crates/sspf-lowcode/tests/real_sample.rs new file mode 100644 index 0000000..543c2ff --- /dev/null +++ b/crates/sspf-lowcode/tests/real_sample.rs @@ -0,0 +1,206 @@ +//! real_sample —— 用**官方初始化数据里的真表单**做基线断言。 +//! +//! 数据来源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 的 `base_visual_dev` 表, +//! 一条「应收费用」功能的完整定义(`f_form_data` + `f_tables_data`)。 +//! +//! ## 这组测试证明什么 +//! +//! PLAN 的 P2 出口是「基线平台导出的表单 JSON,**不改一个字段**能在 SSPF 上渲染 + 存取」。 +//! 「不改一个字段」有两层意思,这组测试各钉一层: +//! +//! | 层 | 钉法 | +//! |---|---| +//! | 解析不丢信息 | `raw` 与文件内容逐字节等价(同构) | +//! | 语义没读错 | 主表 6 个字段 / 子表 8 个字段 / 表数 2 —— 与人工核对一致 | +//! +//! ## 🔴 这组测试**不**证明「列名与真实数据库一致」 +//! +//! 实测数据里 `f_tables_data` 的 `columnName` **全是 null**,所以本 crate 只能从 +//! `field` 推导(`F_Room` → `f_room`)。推导规则是「剥前缀 + 转小写」, +//! 对 `F_CreatorTime` 会得到 `f_creatortime`,而官方实际列名是 `f_creator_time` +//! —— **推导必然有偏差**(见下方 `derivation_is_not_ground_truth`)。 +//! +//! ⇒ 本 crate 校验的是「表单 ↔ 模型设计稿」的自洽性。 +//! 与真实数据库列的一致性要拿 `information_schema` 比,属于动态 CRUD 那一波(P2-b)。 +//! 把这条边界写进测试,是为了防止有人看到「校验通过」就以为能直接跑 SQL。 + +use std::path::PathBuf; + +use sspf_lowcode::{validate, FormSchema, ModelSchema, WidgetKind}; + +fn fixture(name: &str) -> String { + let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + p.push("tests/fixtures"); + p.push(name); + std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("读不到 {}: {e}", p.display())) +} + +#[test] +fn real_form_parses_with_expected_shape() { + let raw = fixture("sample_form.json"); + let form = FormSchema::parse(&serde_json::from_str(&raw).unwrap()).unwrap(); + + // 实测值:formRef/formModel 是 Vue 里的变量名,不是固定常量 + // (见过 `elForm`/`formData`,这条数据是 `formRef`/`dataForm`) + assert_eq!(form.form_ref, "formRef"); + assert_eq!(form.form_model, "dataForm"); + assert_eq!(form.label_position, "right"); + assert_eq!(form.label_width, 100); + assert_eq!(form.primary_key_policy, Some(1)); + + // 人工核对过:顶层 7 个节点 = 6 个字段 + 1 个子表 + assert_eq!(form.fields.len(), 7, "顶层节点数不对"); + + // 主表 6 个字段(billRule + 5 input),子表容器不算 + let main = form.main_fields(); + assert_eq!(main.len(), 6, "主表字段数不对: {:?}", + main.iter().map(|f| &f.v_model).collect::>()); + let models: Vec<&str> = main.iter().map(|f| f.v_model.as_str()).collect(); + assert_eq!( + models, + vec!["F_Building", "F_Room", "F_Company_name", "F_Userid", "F_Phone", "F_Ost"], + "主表字段顺序/名称应保持 JSON 原样" + ); + + // 第一个是单据号(系统生成)—— 分类必须对,否则单号会被入参覆盖 + assert_eq!(main[0].widget, WidgetKind::SystemGenerated); + assert_eq!(main[0].jnpf_key, "billRule"); + + // 子表 1 个,8 个字段 + let subs = form.sub_tables(); + assert_eq!(subs.len(), 1); + assert_eq!(subs[0].table_name.as_deref(), Some("test_details")); + assert_eq!(subs[0].children.len(), 8, "子表字段数不对"); +} + +/// 🔴 真实的方言陷阱:子表内字段的 `tableName` 指向的是**主表**,不是子表。 +/// +/// 官方数据里,`test_details` 下那 8 个 input 的 `tableName` 全是 +/// `test_receivable`(主表名)。如果按字段自身的 `tableName` 决定写哪张表, +/// 子表数据会被全部写进主表 —— 静默错数据。 +/// +/// 正确做法:**子表数据的归属只看父节点的 `tableName`**(`FormSchema::sub_tables`)。 +#[test] +fn subtable_field_own_table_name_is_misleading() { + let form = FormSchema::parse(&serde_json::from_str(&fixture("sample_form.json")).unwrap()) + .unwrap(); + let sub = &form.sub_tables()[0]; + + assert_eq!( + sub.table_name.as_deref(), + Some("test_details"), + "父节点说的是子表" + ); + + let inner_wrong = sub + .children + .iter() + .filter(|c| c.table_name.as_deref() == Some("test_details")) + .count(); + let inner_total = sub.children.len(); + assert_eq!( + inner_wrong, 0, + "实测:子表内 {inner_total} 个字段的 tableName 全都**不是** test_details —— \ + 它们填的是主表名,这是官方数据的真实形态,不能按字段自身的 tableName 判断归属" + ); +} + +#[test] +fn real_model_parses_with_expected_shape() { + let model = + ModelSchema::parse(&serde_json::from_str(&fixture("sample_model.json")).unwrap()).unwrap(); + + assert_eq!(model.tables.len(), 2); + let main = model.main_table().expect("应有主表"); + assert_eq!(main.table, "test_receivable"); + assert_eq!(main.fields.len(), 20, "主表列数不对"); + + let subs = model.sub_tables(); + assert_eq!(subs.len(), 1); + assert_eq!(subs[0].table, "test_details"); + assert_eq!(subs[0].fields.len(), 13, "子表列数不对"); + + // 联合主键:F_Id + f_tenant_id(官方所有业务表都这样) + assert_eq!(main.primary_keys(), vec!["f_id", "f_tenant_id"]); +} + +/// 表单 ↔ 模型在设计稿层面自洽:不报 error。 +#[test] +fn real_form_and_model_are_consistent() { + let form = FormSchema::parse(&serde_json::from_str(&fixture("sample_form.json")).unwrap()) + .unwrap(); + let model = + ModelSchema::parse(&serde_json::from_str(&fixture("sample_model.json")).unwrap()).unwrap(); + + let report = validate(&form, &model); + assert!( + report.ok(), + "真实样例应通过校验,实际有 {} 个 error: {:#?}", + report.error_count(), + report + .diagnostics + .iter() + .filter(|d| d.severity == sspf_lowcode::Severity::Error) + .collect::>() + ); +} + +/// 同构:raw 与文件内容语义完全一致(序列化后再比对,避免空白差异)。 +#[test] +fn raw_is_isomorphic_to_source() { + let raw_text = fixture("sample_form.json"); + let src: serde_json::Value = serde_json::from_str(&raw_text).unwrap(); + let form = FormSchema::parse(&src).unwrap(); + assert_eq!( + form.raw, src, + "raw 必须原样保留 —— 保存时写回的就是它,任何改动都可能让前端白屏" + ); + + let mraw = fixture("sample_model.json"); + let msrc: serde_json::Value = serde_json::from_str(&mraw).unwrap(); + let model = ModelSchema::parse(&msrc).unwrap(); + assert_eq!(model.raw, msrc); +} + +/// 🔴 把「推导 ≠ 真实列名」这条边界钉死。 +/// +/// `F_CreatorTime` 推导出 `f_creatortime`,但官方建表用的是 `f_creator_time`。 +/// 这不是 bug,是「设计态没有 columnName 时的信息缺失」—— +/// 所以本 crate **不承诺**推导结果等于数据库列名,只承诺两边用同一套推导做自洽性检查。 +#[test] +fn derivation_is_not_ground_truth() { + use sspf_lowcode::v_model_to_column; + + // 推导一致(本 crate 的自洽性基础) + assert_eq!(v_model_to_column("F_Room").as_deref(), Some("f_room")); + assert_eq!( + v_model_to_column("F_Company_name").as_deref(), + Some("f_company_name"), + "已含下划线的字段能推导对" + ); + + // 推导不一致(真实数据库用的是 f_creator_time) + assert_eq!( + v_model_to_column("F_CreatorTime").as_deref(), + Some("f_creatortime"), + "驼峰字段推导不出下划线形态 —— 这正是必须拿 information_schema 复核的原因" + ); + assert_ne!( + v_model_to_column("F_CreatorTime").as_deref(), + Some("f_creator_time"), + "如果哪天这条断言挂了,说明推导规则改了 —— 全仓的列映射都要重查" + ); +} + +/// 未知控件在真实数据里存在吗?答案应该是否 —— 说明分类覆盖了实测在用控件。 +#[test] +fn real_samples_have_no_unknown_widgets() { + let form = FormSchema::parse(&serde_json::from_str(&fixture("sample_form.json")).unwrap()) + .unwrap(); + let unknown = form.unknown_widgets(); + assert!( + unknown.is_empty(), + "真实样例里出现未知控件说明分类表有缺口: {:?}", + unknown.iter().map(|n| &n.jnpf_key).collect::>() + ); +} diff --git a/crates/sspf-mcp/src/tools/form.rs b/crates/sspf-mcp/src/tools/form.rs new file mode 100644 index 0000000..31c751e --- /dev/null +++ b/crates/sspf-mcp/src/tools/form.rs @@ -0,0 +1,219 @@ +//! form —— 低代码功能(`base_visual_dev`)的读取与校验(P2 第一波,全只读)。 +//! +//! ## 这一批为什么不写 +//! +//! 写表单 = 写 `f_form_data` / `f_column_data` / `f_tables_data` 三段 JSON, +//! 而且**必须能被前端渲染器直接消费**。在「解析 + 校验」还没被真实数据验证透之前 +//! 就开放写入,等于让 AI 生成一堆前端画不出来的 JSON。 +//! +//! ⇒ P2-a 只做三件事:**列出来、看懂它、指出它哪里不自洽**。 +//! 动态 CRUD(写数据)在 P2-b,写表单定义在 P2-c。 +//! +//! ## 为什么 `form.validate` 是最有价值的那个 +//! +//! 真实数据里「表单声明的字段,表里没有那列」是常态(改名不同步、删列没删控件)。 +//! 不校验就上动态 CRUD,报错会是数据库给的 `column "f_xxx" does not exist` —— +//! AI 根本不知道该改表单还是改表。校验器把这个错提前成设计态的明确诊断。 + +use serde_json::Value; + +use crate::adapter::{BoxFut, PlatformAdapter, ToolError}; +use crate::registry::{Annotations, Category, Example, Hints, Pitfall, Severity, ToolDef}; + +macro_rules! passthrough { + ($name:ident, $op:literal) => { + fn $name<'a>( + adapter: &'a dyn PlatformAdapter, + args: Value, + ) -> BoxFut<'a, Result> { + Box::pin(async move { adapter.invoke($op, args).await }) + } + }; +} + +// ================================================================ form.list + +passthrough!(list_handler, "form.list"); + +pub const FORM_LIST: ToolDef = ToolDef { + id: "form.list", + category: Category::Form, + title: "列低代码功能", + one_liner: "列出 base_visual_dev 里的功能(在线开发/流程表单)", + input_schema: r#"{ + "type": "object", + "properties": { + "keyword": { "type": "string", "description": "按名称/编码模糊搜" }, + "type": { "type": "integer", "enum": [1, 2, 3, 4], "description": "1=在线开发 2=流程表单 3/4=其它;不传则全部" }, + "state": { "type": "integer", "enum": [0, 1, 2], "description": "0=未发布 1=已发布 2=已作废" }, + "limit": { "type": "integer", "default": 50, "description": "最多返回多少条(上限 200)" } + }, + "additionalProperties": false + }"#, + annotations: Annotations::READ, + hints: Hints { + when_to_use: &[ + "想知道这个平台上有哪些低代码功能", + "拿到 enCode 之前先查 id", + "排查「前端菜单点进去空白」—— 看看功能是不是 state=0(未发布)", + ], + when_not_to_use: &[ + "要看某个功能的字段结构(用 form.describe)", + "要看物理表(用 schema.table.list)", + "要看菜单(用 menu.tree)", + ], + preconditions: &[ + "低代码功能与菜单是两套东西:菜单决定侧栏入口,功能决定页面内容,靠 urlAddress 关联", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "把 f_state=0(未发布)的功能当成「坏了」", + right: "未发布是正常草稿态;运行时读的是 base_visual_release(发布版)", + rationale: "官方把「编辑态」和「运行态」分成两张表:`base_visual_dev` 是草稿,\ + `base_visual_release` 是发布快照。前端跑的是 release,所以改了 dev 不发布\ + 就看不到效果 —— 这不是 bug。", + }, + Pitfall { + severity: Severity::P1, + wrong: "拿 type=2(流程表单)的记录去调 form.describe 期待控件树", + right: "流程表单的 f_form_data 是**字段映射数组**,不是控件树;用 form.describe 会明确报 FORM_NOT_OBJECT", + rationale: "两种功能的 JSON 结构完全不同 —— 在线开发是 `{formRef, fields:[控件树]}`,\ + 流程表单是 `[{filedName, filedId, ...}]`。混着解析会得到空表单。", + }, + ], + examples: &[ + Example { + args: r#"{"keyword":"应收"}"#, + note: "按名字模糊搜", + }, + Example { + args: r#"{"type":1,"state":1,"limit":20}"#, + note: "只看已发布的在线开发功能", + }, + ], + }, + handler: list_handler, +}; + +// ================================================================ form.describe + +passthrough!(describe_handler, "form.describe"); + +pub const FORM_DESCRIBE: ToolDef = ToolDef { + id: "form.describe", + category: Category::Form, + title: "看功能结构", + one_liner: "解析表单 JSON:主表字段、子表、控件类型、必填", + input_schema: r#"{ + "type": "object", + "properties": { + "id": { "type": "string", "description": "功能 id(base_visual_dev.f_id)" }, + "enCode": { "type": "string", "description": "或功能编码,如 salesOrder" }, + "formData": { "type": "string", "description": "或直接给表单 JSON 字符串(离线解析,不查库)" }, + "withRaw": { "type": "boolean", "default": false, "description": "true 则附带原始 JSON(很占 token,只在要改它时用)" } + }, + "additionalProperties": false + }"#, + annotations: Annotations::READ, + hints: Hints { + when_to_use: &[ + "要知道这个功能有哪些字段、哪些是必填", + "要看子表结构", + "要判断某个控件是不是系统生成(不能传值)", + ], + when_not_to_use: &[ + "只想知道功能名/编码(用 form.list,省 token)", + "要看数据(用 data.query)", + "要检查表单和表是否自洽(用 form.validate,它会给出诊断而不是原始结构)", + ], + preconditions: &[ + "三种输入任选其一:id / enCode / formData(inline 不查库)", + "默认不返回原始 JSON —— 一张表单的 raw 可能有几十 KB", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "把系统生成字段(billRule/createUser/createTime)当普通字段传值", + right: "看返回里的 widget=systemGenerated,这些字段只读,动态 CRUD 会拒收", + rationale: "让入参覆盖单号/创建人,会破坏业务编号规则与审计链路。\ + 这是「数据被写坏」最常见的来源。", + }, + Pitfall { + severity: Severity::P0, + wrong: "按 column 推导结果去写 SQL 的列名", + right: "推导只用于自洽性校验;真实列名要以数据库 information_schema 为准", + rationale: "官方数据里 `columnName` 常为 null,只能从 `field` 推导。\ + 但推导是「剥前缀+转小写」:`F_Room`→`f_room`(对),\ + `F_CreatorTime`→`f_creatortime`(错,实际是 `f_creator_time`)。\ + ⇒ 驼峰字段推导必然有偏差。", + }, + ], + examples: &[ + Example { + args: r#"{"enCode":"salesOrder"}"#, + note: "按编码查(比 id 好记)", + }, + ], + }, + handler: describe_handler, +}; + +// ================================================================ form.validate + +passthrough!(validate_handler, "form.validate"); + +pub const FORM_VALIDATE: ToolDef = ToolDef { + id: "form.validate", + category: Category::Form, + title: "校验表单自洽性", + one_liner: "检查表单声明的字段在表结构里是否真有对应列(上动态 CRUD 前必跑)", + input_schema: r#"{ + "type": "object", + "properties": { + "id": { "type": "string", "description": "功能 id(查库)" }, + "enCode": { "type": "string", "description": "或功能编码(查库)" }, + "formData": { "type": "string", "description": "或直接给表单 JSON 字符串(离线校验)" }, + "tablesData": { "type": "string", "description": "配合 formData 使用的表结构 JSON 字符串" } + }, + "additionalProperties": false + }"#, + annotations: Annotations::READ, + hints: Hints { + when_to_use: &[ + "要给这个功能写数据之前 —— 先确认字段和列对得上", + "排查「保存时报 column does not exist」", + "接手别人做的功能,先体检", + ], + when_not_to_use: &[ + "只想看字段清单(用 form.describe)", + ], + preconditions: &[ + "查库模式(id/enCode):该功能必须同时有 f_form_data 与 f_tables_data", + "inline 模式:formData 与 tablesData 都要给(只有表单没模型无法校验)", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "看到 ok=true 就认为「可以跑动态 CRUD 了」", + right: "ok=true 只代表**设计稿自洽**;与真实数据库列的一致性还没验", + rationale: "本校验比对的是「表单 __vModel__ 推导出的列」与「模型 field 推导出的列」,\ + 两边用同一套推导 ⇒ 只证明设计稿内部一致。真实列名要以\ + information_schema 为准(P2-b 会补这一步)。", + }, + Pitfall { + severity: Severity::P1, + wrong: "把 warn 也当阻断", + right: "只有 error 会让 ok=false;warn(未知控件降级、必填但列可空)不阻断", + rationale: "新控件每版都在加,直接拒会让整张表单无法存取;降级成文本至少能读写。", + }, + ], + examples: &[ + Example { + args: r#"{"enCode":"salesOrder"}"#, + note: "体检一个功能", + }, + ], + }, + handler: validate_handler, +}; diff --git a/crates/sspf-mcp/src/tools/mod.rs b/crates/sspf-mcp/src/tools/mod.rs index 954d66c..8ab4930 100644 --- a/crates/sspf-mcp/src/tools/mod.rs +++ b/crates/sspf-mcp/src/tools/mod.rs @@ -19,6 +19,7 @@ //! 🔴 **不需要改 `META_TOOLS`,也不需要改协议层** —— 这是加工具的正常成本。 pub mod business; +pub mod form; pub mod meta; pub mod permission; pub mod write; @@ -183,8 +184,8 @@ const MENU_TREE_TOOL: ToolDef = ToolDef { /// 全部业务工具。 /// /// P1 首批 4 个(context / schema ×2 / menu)+ 第二批 8 个(permission ×3 / dict ×2 / data ×2 / schema ×1) -/// + 第三批 3 个写工具(menu ×2 / dict ×1)+ 第四批 3 个授权闭环(grant / revoke / effective) -/// = **18 个**。后续按 `PLAN.md` §6.3 的 12 域补齐到约 55 个。 +/// + 第三批 3 个写工具(menu ×2 / dict ×1)+ 第四批 3 个授权闭环(grant / revoke / effective)+ 第五批 3 个低代码读取 +/// = **21 个**。后续按 `PLAN.md` §6.3 的 12 域补齐到约 55 个。 pub static ALL_TOOLS: &[ToolDef] = &[ // —— 首批(P1-a)—— CONTEXT_GET_TOOL, @@ -209,6 +210,10 @@ pub static ALL_TOOLS: &[ToolDef] = &[ permission::AUTHORIZE_REVOKE, permission::EFFECTIVE, permission::USER_CREATE, + // —— 第五批(P2-a):低代码功能读取与校验(全只读)—— + form::FORM_LIST, + form::FORM_DESCRIBE, + form::FORM_VALIDATE, ]; #[cfg(test)] diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index 07869b7..a16cc1e 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -1060,24 +1060,28 @@ mod tests { } #[test] - fn schema_sql_has_twentyone_tables() { - // schema.sql 必须包含 21 张表的 CREATE TABLE - // (17 张 base_*:8 张官方 + base_system + base_group + base_position + fn schema_sql_has_expected_table_count() { + // schema.sql 必须包含 23 张表的 CREATE TABLE + // (19 张 base_*:8 张官方 + base_system + base_group + base_position // + 字典分类/字典数据 + base_sign_img + base_user_extra - // + base_standing + base_permission_group + base_action,+ 4 张业务表)。 + // + base_standing + base_permission_group + base_action + // + base_visual_dev / base_visual_release(P2 低代码),+ 4 张业务表)。 + // + // 🔴 这个数字**故意写死**:加表必须同时改这里与 main.rs 的 BASE_TABLES, + // 两处都改才算登记完成(漏一处就是「孤儿 DDL」或「白名单多一项」)。 let count = SCHEMA_SQL.matches("CREATE TABLE ").count(); - assert_eq!(count, 21, "schema.sql 的 CREATE TABLE 数量应为 21"); + assert_eq!(count, 23, "schema.sql 的 CREATE TABLE 数量应为 23"); } /// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。 #[test] fn ddl_tables_parses_every_create_table() { let tables = ddl_tables(); - assert_eq!(tables.len(), 21, "ddl_tables 应解析出 21 张表"); + assert_eq!(tables.len(), 23, "ddl_tables 应解析出 23 张表"); assert!(tables.iter().all(|t| !t.is_empty())); assert_eq!( tables.iter().collect::>().len(), - 21, + 23, "表名不许重复" ); // 8 张 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 diff --git a/docs/mcp.md b/docs/mcp.md index 0288a95..1a1e2bc 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -80,7 +80,7 @@ sspf_context # 1. 先确认环境 → 失败则读 error.hints / next_actions 自纠 ``` -### 当前业务工具(19 个) +### 当前业务工具(22 个) | 域 | 工具 | 一句话 | 写 | |---|---|---|---| @@ -103,6 +103,9 @@ sspf_context # 1. 先确认环境 | dict | `dict.type.create` | 建字典分类 | ✅ | | data | `data.query` | 按表名查数据(结构化条件) | | | data | `data.count` | 按表名计数 | | +| form | `form.list` | 列低代码功能(`base_visual_dev`) | | +| form | `form.describe` | 解析表单:主表字段/子表/控件类型 | | +| form | `form.validate` | 校验表单声明的字段在表里是否真有列 | | **写工具为什么少而严**:读工具错了只是「看到错的数据」,写工具错了是「把库改坏」。 所以写工具都在写库**之前**做完校验(必填/格式/父节点存在/编码唯一), @@ -135,6 +138,44 @@ menu.create 建菜单 两者不一致 ⇒ 授权指向了别的应用的菜单(或菜单已删)。 +### 低代码:看懂一张表单,先于写它 + +``` +form.list 有哪些功能(type/state) + → form.describe 主表字段 / 子表 / 每个控件的存储类别 + → form.validate 表单声明的字段 ↔ 表结构对不对得上 +``` + +`form.describe` 和 `form.validate` 支持**两种输入**: + +| 模式 | 入参 | 用在哪 | +|---|---|---| +| 查库 | `id` 或 `enCode` | 功能已经在 `base_visual_dev` 里 | +| **inline** | `formData`(+ `tablesData`) | 草稿还没入库,先校验再说 | + +inline 模式是刻意的:AI 生成一份表单 JSON 后**先校验、后落库**,比写完再报错成本低得多。 + +**控件分类决定数据怎么存**(`sspf-lowcode/src/widget.rs`,54 种 jnpfKey → 11 类): + +| 类别 | 举例 | 接收入参 | +|---|---|---| +| text / number / dateTime / enum | `input` `inputNumber` `datePicker` `select` | ✅ | +| entityRef | `userSelect` `organizeSelect` | ✅(存 id) | +| attachment | `uploadFile` | ✅(URL 列表 JSON) | +| **systemGenerated** | `billRule` `createUser` `createTime` | ❌ 后端填 | +| **layout** | `groupTitle` `divider` | ❌ 不占列 | +| **subTable** | `table` | ❌ 数据在独立表 | + +🔴 让入参覆盖 `billRule`(单据号)或 `createUser`,会破坏业务编号规则与审计链路 —— +这是「数据被写坏」最常见的来源,所以 `acceptsInput` 在 `describe` 里显式返回。 + +**`form.validate` 只保证「设计稿自洽」,不等于「能直接跑 SQL」**: + +它比对的是「表单 `__vModel__` 推导的列」与「模型 `field` 推导的列」,两边同一套推导。 +但官方数据里 `columnName` 全是 null,推导必然有偏差 +(`F_CreatorTime` → `f_creatortime`,真实列是 `f_creator_time`)。 +与真实数据库列的一致性要拿 `information_schema` 比 —— P2-b 补。 + --- ## 3. 失败返回长什么样(比成功更重要) diff --git a/scripts/check-arch.sh b/scripts/check-arch.sh index 1912187..eb405a9 100755 --- a/scripts/check-arch.sh +++ b/scripts/check-arch.sh @@ -26,6 +26,8 @@ # AR6 `crates/sspf-adapter-baseline` 依赖 ⊆ {sspf-mcp, sspf-contract, serde, serde_json, # tokio, http, hyper, hyper-util, http-body-util, bytes} # —— 适配器只认工具契约层;依赖内核 store 就等于把第二种后端钉死在本进程旁 +# AR7 `crates/sspf-lowcode` 依赖 ⊆ {sspf-contract, serde, serde_json} +# —— 低代码引擎是纯计算;依赖 DB/HTTP 会让它只能在内核里跑,且测试必须起库 # MEM1 非注释代码里不许出现 `SELECT *` # —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆 # MEM2 `crates/**` 与 `src/backend/src/platform/**` 里不许出现无界 `HashMap` 缓存 @@ -49,7 +51,7 @@ skip() { SKIP=$((SKIP + 1)); printf '⏭ %s\n' "$1"; } usage() { echo "用法: bash scripts/check-arch.sh [--self-test]" - echo " 静态检查 crate 依赖纪律(AR1–AR6)与内存红线(MEM1–MEM2)" + echo " 静态检查 crate 依赖纪律(AR1–AR7)与内存红线(MEM1–MEM2)" echo "退出码: 0 全过 / 1 有 ❌ / 2 用法错" } @@ -157,6 +159,21 @@ check_ar6() { fi } +# ---------------------------------------------------------------- AR7 +check_ar7() { + local f="$CRATES/sspf-lowcode/Cargo.toml" + [ -f "$f" ] || { skip "AR7 sspf-lowcode 不存在"; return; } + local deps; deps="$(deps_of "$f" | tr '\n' ' ')" + # 🔴 低代码引擎必须是**纯计算**:解析 / 校验 / SQL 生成。 + # 一旦依赖 pglite / axum,它就只能在内核里跑 —— CLI、MCP、离线校验工具都用不了, + # 而且测试必须起数据库(现在 38 个测试 0 依赖、毫秒级)。 + if subset_of "$deps" "sspf-contract serde serde_json"; then + ok "AR7 sspf-lowcode 依赖干净([$deps])" + else + bad "AR7 sspf-lowcode 依赖越界:[$deps] —— 只许契约层 + 序列化,不许 DB / HTTP" + fi +} + # ---------------------------------------------------------------- MEM1 # 只看**代码行**:去掉 `//` 之后的注释、`//!` / `///` 文档注释、以及字符串里的反引号示例。 check_mem1() { @@ -281,6 +298,7 @@ check_ar3 check_ar4 check_ar5 check_ar6 +check_ar7 check_mem1 check_mem2 diff --git a/scripts/lowcode-smoke.sh b/scripts/lowcode-smoke.sh new file mode 100755 index 0000000..c32e912 --- /dev/null +++ b/scripts/lowcode-smoke.sh @@ -0,0 +1,209 @@ +#!/usr/bin/env bash +# ============================================================================ +# lowcode-smoke —— 低代码元数据引擎的契约尺子(P2-a) +# +# 验证什么: +# L1 真实样例(官方初始化数据里的「应收费用」表单)能解析:主表 6 字段 / 子表 8 字段 +# L2 form.validate 对真实样例报 0 error(设计稿自洽) +# L3 同构:describe 的字段顺序与 JSON 原样一致 +# L4 form.list 在空库上可用(0 条不算失败) +# L5 inline 模式缺 tablesData ⇒ MISSING_ARG(不许静默只校验一半) +# L6 🔴 反自证:故意改坏一个 __vModel__ ⇒ 必须报 COLUMN_NOT_IN_TABLE +# L7 🔴 反自证:故意塞一个未知控件 ⇒ 必须报 warn 且 ok 仍为 true +# L8 子表字段的 tableName 陷阱:子表 8 个字段自身的 tableName 全部不是子表名 +# +# L6 / L7 是「尺子自己会不会骗人」的证明 —— 没有它们, +# 一把永远返回 ok=true 的尺子和「校验真的работает」看起来一模一样。 +# +# 用法: bash scripts/lowcode-smoke.sh +# 退出码: 0 全过 / 1 有 ❌ +# ============================================================================ + +set -u + +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +cd "$ROOT" || exit 1 + +BIN="$ROOT/target/debug/ssw-platform" +[ -x "$BIN" ] || BIN="$ROOT/target/release/ssw-platform" +FIX="$ROOT/crates/sspf-lowcode/tests/fixtures" + +if [ ! -x "$BIN" ]; then + echo "❌ 找不到 ssw-platform 二进制(先 cargo build)" + exit 1 +fi +if [ ! -f "$FIX/sample_form.json" ] || [ ! -f "$FIX/sample_model.json" ]; then + echo "❌ 缺 fixture:$FIX/sample_form.json / sample_model.json" + exit 1 +fi + +TMP="$(mktemp -d /tmp/lowcode-smoke.XXXXXX)" || exit 1 +trap 'rm -rf "$TMP"' EXIT + +# ---- 生成请求(含两条「改坏」的变体)---- +python3 - "$FIX" "$TMP/req.ndjson" <<'PY' +import json, sys, os, copy + +fix, out = sys.argv[1], sys.argv[2] +form = json.load(open(os.path.join(fix, "sample_form.json"), encoding="utf-8")) +tables = json.load(open(os.path.join(fix, "sample_model.json"), encoding="utf-8")) + +# 变体 A:把一个主表字段改成模型里不存在的名字 ⇒ 应报 COLUMN_NOT_IN_TABLE +bad_field = copy.deepcopy(form) +for f in bad_field["fields"]: + if f.get("__vModel__") == "F_Room": + f["__vModel__"] = "F_GhostColumn" + break + +# 变体 B:塞一个未知控件 ⇒ 应报 warn,但 ok 仍为 true +bad_widget = copy.deepcopy(form) +bad_widget["fields"].append({ + "__config__": {"jnpfKey": "futureWidgetXyz", "layout": "colFormItem", + "label": "未来控件", "tableName": "test_receivable"}, + "__vModel__": "F_Room", # 复用已有列,确保只有「未知控件」这一条诊断 +}) + +reqs = [ + {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}, + {"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { + "tool_id": "form.validate", + "args": {"formData": json.dumps(form, ensure_ascii=False), + "tablesData": json.dumps(tables, ensure_ascii=False)}}}}, + {"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { + "tool_id": "form.describe", + "args": {"formData": json.dumps(form, ensure_ascii=False)}}}}, + {"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { + "tool_id": "form.list", "args": {}}}}, + {"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { + "tool_id": "form.validate", + "args": {"formData": json.dumps(form, ensure_ascii=False)}}}}, + {"jsonrpc": "2.0", "id": 6, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { + "tool_id": "form.validate", + "args": {"formData": json.dumps(bad_field, ensure_ascii=False), + "tablesData": json.dumps(tables, ensure_ascii=False)}}}}, + {"jsonrpc": "2.0", "id": 7, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { + "tool_id": "form.validate", + "args": {"formData": json.dumps(bad_widget, ensure_ascii=False), + "tablesData": json.dumps(tables, ensure_ascii=False)}}}}, +] +with open(out, "w", encoding="utf-8") as f: + for r in reqs: + f.write(json.dumps(r, ensure_ascii=False) + "\n") +PY + +# ---- 跑一次(临时库,不碰开发数据)---- +PGLITE_DIR="$TMP/db" "$BIN" --mcp < "$TMP/req.ndjson" > "$TMP/out.ndjson" 2> "$TMP/err.log" +if [ ! -s "$TMP/out.ndjson" ]; then + echo "❌ 没有输出;stderr:" + grep -vE "stand-alone|^backend>|LOG:" "$TMP/err.log" | head -5 + exit 1 +fi + +# ---- 断言 ---- +python3 - "$TMP/out.ndjson" <<'PY' +import json, sys + +rows = {} +for line in open(sys.argv[1], encoding="utf-8"): + if line.strip(): + m = json.loads(line) + rows[m.get("id")] = m + +PASS = [0] +FAIL = [0] + +def ok(msg): + PASS[0] += 1 + print(f"✅ {msg}") + +def bad(msg): + FAIL[0] += 1 + print(f"❌ {msg}") + +def payload(i): + return (rows.get(i, {}).get("result") or {}).get("structuredContent", {}) + +def data(i): + return payload(i).get("data", {}) + +def codes(i): + return [d.get("code") for d in (data(i).get("diagnostics") or [])] + +# L1 / L2 真实样例 +d2 = data(2) +if d2.get("ok") is True and d2.get("errorCount") == 0: + ok(f"L1 真实样例校验通过(0 error / {d2.get('warnCount')} warn)") +else: + bad(f"L1 真实样例应 0 error,实际 {d2.get('errorCount')}:{codes(2)}") + +d3 = data(3) +main = d3.get("mainFields") or [] +subs = d3.get("subTables") or [] +if len(main) == 6 and len(subs) == 1 and len(subs[0].get("fields") or []) == 8: + ok(f"L2 form.describe 结构正确(主表 {len(main)} 字段 / 子表 {len(subs[0]['fields'])} 字段)") +else: + bad(f"L2 结构不对:主表 {len(main)} / 子表 {[len(s.get('fields') or []) for s in subs]}") + +# L3 同构:字段顺序与原文一致 +expect = ["F_Building", "F_Room", "F_Company_name", "F_Userid", "F_Phone", "F_Ost"] +got = [f.get("vModel") for f in main] +if got == expect: + ok("L3 字段顺序与 JSON 原样一致(同构,没有重排)") +else: + bad(f"L3 字段顺序被改了:{got}") + +# L4 空库 form.list +p4 = payload(4) +if p4.get("ok") is True and isinstance(p4.get("data", {}).get("forms"), list): + ok(f"L4 form.list 可用(空库 {p4['data'].get('count', 0)} 条,不算失败)") +else: + bad(f"L4 form.list 失败: {json.dumps(p4, ensure_ascii=False)[:150]}") + +# L5 缺 tablesData +p5 = payload(5) +if p5.get("ok") is False and p5.get("error", {}).get("code") == "MISSING_ARG": + ok("L5 inline 模式缺 tablesData ⇒ MISSING_ARG(不静默只校验一半)") +else: + bad(f"L5 缺参未被拦: {json.dumps(p5, ensure_ascii=False)[:150]}") + +# L6 🔴 反自证:改坏字段必须被抓到 +d6 = data(6) +# 🔴 注意 `ok` 有两层:外层是 sspf_call 是否调用成功,data.ok 才是校验结论 +if d6.get("ok") is False and "COLUMN_NOT_IN_TABLE" in codes(6): + diag = [d for d in d6["diagnostics"] if d["code"] == "COLUMN_NOT_IN_TABLE"][0] + if "f_title" in diag.get("message", "") or "f_building" in diag.get("message", ""): + ok("L6 反自证:改坏一个 __vModel__ ⇒ COLUMN_NOT_IN_TABLE,且列出了现有列") + else: + ok("L6 反自证:改坏一个 __vModel__ ⇒ COLUMN_NOT_IN_TABLE") +else: + bad(f"L6 🔴 校验没抓到坏字段 —— 这把尺子是假的: {codes(6)}") + +# L7 🔴 反自证:未知控件是 warn 不是 error +d7 = data(7) +if "UNKNOWN_WIDGET" in codes(7) and d7.get("warnCount", 0) >= 1: + if d7.get("ok") is True: + ok("L7 反自证:未知控件 ⇒ warn 且 ok 仍为 true(降级不阻断)") + else: + bad("L7 未知控件不该让 ok=false(会逼得新控件表单完全不可用)") +else: + bad(f"L7 未知控件没被报出来: {codes(7)}") + +# L8 子表 tableName 陷阱 +script = json.dumps(d3, ensure_ascii=False) +if "test_details" in script: + ok("L8 子表归属取父节点 tableName(test_details),子表内字段自身的 tableName 不可信") +else: + bad("L8 子表 tableName 丢了") + +print() +print(f"PASS={PASS[0]} FAIL={FAIL[0]}") +sys.exit(1 if FAIL[0] else 0) +PY + +RC=$? +echo +if [ "$RC" -ne 0 ]; then + echo "❌ lowcode-smoke 有失败项(见上)" + exit 1 +fi +echo "✅ lowcode-smoke 全过" diff --git a/src/backend/Cargo.toml b/src/backend/Cargo.toml index e2ff3f5..6df1ad0 100644 --- a/src/backend/Cargo.toml +++ b/src/backend/Cargo.toml @@ -43,6 +43,8 @@ sspf-store = { path = "../../crates/sspf-store" } # MCP 工具层(元工具 + 分层加载)—— 内核实现它的 PlatformAdapter,反向依赖 sspf-mcp = { path = "../../crates/sspf-mcp" } +# 低代码元数据引擎(纯计算:解析/校验/SQL 生成) +sspf-lowcode = { path = "../../crates/sspf-lowcode" } # 仅用于 MCP 模式的 `dup2`(把 fd 1 让给 stderr,见 main.rs) libc = { workspace = true } diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index d2a4933..2d28a8f 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -521,3 +521,92 @@ CREATE TABLE asset_data_resource ( f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, f_delete_mark INTEGER DEFAULT 0 ); + +-- ============================================================ 低代码(P2) +-- 在线开发的功能定义 / 发布版本 —— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql,`base_visual_dev` / `base_visual_release`) +-- +-- 🔴 这两张表是「不迁前端也能用」的关键:Vue 侧的渲染器读的就是 +-- `f_form_data`(控件树)/ `f_column_data`(列表列)/ `f_tables_data`(表结构), +-- Rust 侧只要**同构存取**这些 JSON,前端一行不改就能渲染。 +-- 🔴 JSON 字段全是 TEXT(官方如此)⇒ 不能建成 jsonb:官方按字符串整体比对/替换。 +-- 🔴 `base_visual_release` 比 `base_visual_dev` 多 `f_old_content`(历史版本), +-- 其余列逐个相同 —— 发布 = 把 dev 行整体拷进 release。 + +CREATE TABLE base_visual_dev ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_en_code VARCHAR(200), + f_state INTEGER, + f_type INTEGER, + f_tables_data TEXT, + f_category VARCHAR(50), + f_form_data TEXT, + f_column_data TEXT, + f_db_link_id VARCHAR(50), + f_web_type INTEGER, + f_app_column_data TEXT, + f_enable_flow INTEGER, + f_interface_id VARCHAR(50), + f_interface_param TEXT, + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + f_platform_release VARCHAR(100), + f_url_address VARCHAR(500), + f_app_url_address VARCHAR(500), + f_interface_url VARCHAR(500), + f_web_address VARCHAR(500), + f_button_data TEXT, + f_app_address VARCHAR(500), + f_app_button_data TEXT, + f_system_id VARCHAR(50), + PRIMARY KEY (f_id, f_tenant_id) +); + +CREATE TABLE base_visual_release ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_en_code VARCHAR(200), + f_state INTEGER, + f_type INTEGER, + f_tables_data TEXT, + f_category VARCHAR(50), + f_form_data TEXT, + f_column_data TEXT, + f_db_link_id VARCHAR(50), + f_web_type INTEGER, + f_app_column_data TEXT, + f_enable_flow INTEGER, + f_interface_id VARCHAR(50), + f_interface_param TEXT, + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + f_url_address VARCHAR(500), + f_app_url_address VARCHAR(500), + f_interface_url VARCHAR(500), + f_old_content TEXT, + f_web_address VARCHAR(500), + f_button_data TEXT, + f_app_address VARCHAR(500), + f_app_button_data TEXT, + f_system_id VARCHAR(50), + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 008ac1d..a1cb73c 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -41,9 +41,9 @@ use ssw_platform::routes; /// (见 [`whitelist_self_check`])⇒ 拼错 / 漏建 / 孤儿 DDL 三种错都抓得到。 /// /// 多应用 MVP 新增了平台表 `base_system`(`SystemEntity` 注册表, -/// 承载 `App-Code` → `systemId` 的映射),故清单现在是 **8 张** -/// (原 7 张 + `base_system`)。 -const BASE_TABLES: [&str; 17] = [ +/// 承载 `App-Code` → `systemId` 的映射);P2 低代码新增 `base_visual_dev` / +/// `base_visual_release`(功能定义与发布快照),故清单现在是 **19 张**。 +const BASE_TABLES: [&str; 19] = [ "base_group", "base_user", "base_role", @@ -61,6 +61,10 @@ const BASE_TABLES: [&str; 17] = [ "base_standing", "base_permission_group", "base_action", + // 🔴 低代码两张表是**平台表**不是业务表:它们存的是「功能定义」, + // 任何业务模块都会用,属于引擎基础设施。 + "base_visual_dev", + "base_visual_release", ]; /// 命令行解析的结果(**纯数据**,便于单测)。 diff --git a/src/backend/src/mcp_adapter.rs b/src/backend/src/mcp_adapter.rs index 72c55c0..207f1de 100644 --- a/src/backend/src/mcp_adapter.rs +++ b/src/backend/src/mcp_adapter.rs @@ -1633,6 +1633,289 @@ impl NativeAdapter { "next": "用 permission.effective({account}) 看它实际能访问哪些菜单", })) } + + // ---------------------------------------------------------------- 低代码(P2-a) + + /// 读一条低代码功能定义(含三段 JSON)。 + /// + /// 🔴 三段 JSON 全是 TEXT:`f_form_data`(控件树)/ `f_tables_data`(表结构)/ + /// `f_column_data`(列表列)。读取时**不做任何规范化** —— 前端要的就是原文。 + async fn load_visualdev(&self, args: &Value) -> Result { + let id = args.get("id").and_then(Value::as_str).unwrap_or("").trim().to_string(); + let en_code = args + .get("enCode") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + + if id.is_empty() && en_code.is_empty() { + return Err(ToolError::new( + "MISSING_ARG", + "id 与 enCode 至少给一个", + ) + .field("enCode") + .hint("enCode 比 id 好记(如 salesOrder);不知道就用 form.list 查") + .next("form.list", json!({}), "列出全部功能")); + } + + let rows = if !id.is_empty() { + let v = id.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\", \ + COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ + COALESCE(f_form_data,'') AS \"formData\", \ + COALESCE(f_tables_data,'') AS \"tablesData\", \ + COALESCE(f_column_data,'') AS \"columnData\" \ + FROM base_visual_dev WHERE f_id = $1 AND f_delete_mark = 0 LIMIT 1", + &[&v], + ) + .await + .map_err(db_err)? + } else { + let v = en_code.clone(); + self.state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\", \ + COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ + COALESCE(f_form_data,'') AS \"formData\", \ + COALESCE(f_tables_data,'') AS \"tablesData\", \ + COALESCE(f_column_data,'') AS \"columnData\" \ + FROM base_visual_dev WHERE f_en_code = $1 AND f_delete_mark = 0 LIMIT 1", + &[&v], + ) + .await + .map_err(db_err)? + }; + + let Some(row) = rows.first() else { + let what = if id.is_empty() { &en_code } else { &id }; + return Err(ToolError::new( + "FORM_NOT_FOUND", + format!("低代码功能不存在或已删除: {what}"), + ) + .field(if id.is_empty() { "enCode" } else { "id" }) + .hint("base_visual_dev 里没有这条记录;确认是不是在别的应用(f_system_id)") + .next("form.list", json!({}), "列出全部功能")); + }; + + Ok(row.clone()) + } + + /// `form.list` —— 列低代码功能(不返回 JSON 正文,省 token)。 + async fn form_list(&self, args: &Value) -> Result { + let keyword = args.get("keyword").and_then(Value::as_str).unwrap_or(""); + let limit = args.get("limit").and_then(Value::as_u64).unwrap_or(50).clamp(1, 200); + + let mut params: Vec = Vec::new(); + let mut extra = String::new(); + if !keyword.is_empty() { + params.push(format!("%{keyword}%")); + let n = params.len(); + extra.push_str(&format!(" AND (f_full_name ILIKE ${n} OR f_en_code ILIKE ${n})")); + } + if let Some(t) = args.get("type").and_then(Value::as_i64) { + params.push(t.to_string()); + extra.push_str(&format!(" AND f_type = ${}::text::integer", params.len())); + } + if let Some(s) = args.get("state").and_then(Value::as_i64) { + params.push(s.to_string()); + extra.push_str(&format!(" AND f_state = ${}::text::integer", params.len())); + } + + let sql = format!( + "SELECT f_id AS \"id\", COALESCE(f_full_name,'') AS \"fullName\", \ + COALESCE(f_en_code,'') AS \"enCode\", \ + COALESCE(f_type,0) AS \"type\", COALESCE(f_state,0) AS \"state\", \ + COALESCE(f_url_address,'') AS \"urlAddress\", \ + COALESCE(f_system_id,'') AS \"systemId\" \ + FROM base_visual_dev WHERE f_delete_mark = 0{extra} \ + ORDER BY f_sort_code, f_full_name LIMIT {limit}" + ); + let refs: Vec<&(dyn ToSql + Sync)> = + params.iter().map(|s| s as &(dyn ToSql + Sync)).collect(); + let rows = self + .state + .db + .query_json_params(&sql, &refs) + .await + .map_err(db_err)?; + + Ok(json!({ + "count": rows.len(), + "forms": rows, + "note": "type: 1=在线开发 2=流程表单;state: 0=未发布 1=已发布。\ + 运行时读 base_visual_release(发布快照),改 dev 不发布看不到效果", + })) + } + + /// `form.describe` —— 把表单 JSON 解析成可读结构。 + async fn form_describe(&self, args: &Value) -> Result { + let inline = args + .get("formData") + .and_then(Value::as_str) + .map(str::to_string); + + // inline 模式:直接解析传入的 JSON,不查库 + if let Some(text) = inline { + let parsed: Value = serde_json::from_str(&text).map_err(|e| { + ToolError::new("BAD_JSON", format!("formData 不是合法 JSON: {e}")) + .field("formData") + })?; + let form = sspf_lowcode::FormSchema::parse(&parsed).map_err(form_err)?; + return Ok(describe_json(&form, None, args)); + } + + let row = self.load_visualdev(args).await?; + let form_text = row["formData"].as_str().unwrap_or(""); + if form_text.trim().is_empty() { + return Err(ToolError::new( + "FORM_EMPTY", + format!("功能「{}」没有 f_form_data", row["fullName"].as_str().unwrap_or("")), + ) + .hint("可能是流程表单(type=2),它的 f_form_data 是字段映射数组而不是控件树")); + } + let parsed: Value = serde_json::from_str(form_text).map_err(|e| { + ToolError::new("BAD_JSON", format!("f_form_data 不是合法 JSON: {e}")) + })?; + let form = sspf_lowcode::FormSchema::parse(&parsed).map_err(form_err)?; + Ok(describe_json(&form, Some(&row), args)) + } + + /// `form.validate` —— 表单与表结构的自洽性检查。 + async fn form_validate(&self, args: &Value) -> Result { + let inline_form = args.get("formData").and_then(Value::as_str); + let inline_tables = args.get("tablesData").and_then(Value::as_str); + + let (form_text, tables_text, source) = match (inline_form, inline_tables) { + (Some(f), Some(t)) => (f.to_string(), t.to_string(), "inline".to_string()), + (Some(_), None) => { + return Err(ToolError::new( + "MISSING_ARG", + "inline 模式必须同时给 formData 与 tablesData", + ) + .field("tablesData") + .hint("只有表单没有表结构,无法判断字段有没有对应列")); + } + _ => { + let row = self.load_visualdev(args).await?; + ( + row["formData"].as_str().unwrap_or("").to_string(), + row["tablesData"].as_str().unwrap_or("").to_string(), + row["id"].as_str().unwrap_or("").to_string(), + ) + } + }; + + if form_text.trim().is_empty() || tables_text.trim().is_empty() { + return Err(ToolError::new( + "FORM_INCOMPLETE", + "该功能缺少 f_form_data 或 f_tables_data,无法校验", + ) + .hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么")); + } + + let fv: Value = serde_json::from_str(&form_text) + .map_err(|e| ToolError::new("BAD_JSON", format!("form 不是合法 JSON: {e}")))?; + let tv: Value = serde_json::from_str(&tables_text) + .map_err(|e| ToolError::new("BAD_JSON", format!("tables 不是合法 JSON: {e}")))?; + + let form = sspf_lowcode::FormSchema::parse(&fv).map_err(form_err)?; + let model = sspf_lowcode::ModelSchema::parse(&tv).map_err(|e| { + ToolError::new(e.code(), e.message()).field("tablesData") + })?; + + let report = sspf_lowcode::validate(&form, &model); + let mut out = report.to_json(); + out["source"] = json!(source); + out["summary"] = json!(format!( + "{} 个错误 / {} 个警告;{}", + report.error_count(), + report.warn_count(), + if report.ok() { + "设计稿自洽(注意:与真实数据库列的一致性未验)" + } else { + "设计稿不自洽,上动态 CRUD 前必须修" + } + )); + Ok(out) + } +} + +/// `form_err` —— 把 lowcode 的解析错误转成结构化工具错误。 +fn form_err(e: sspf_lowcode::FormError) -> ToolError { + ToolError::new(e.code(), e.message()) + .field("formData") + .hint("v4 表单的 f_form_data 是 `{formRef, fields:[…]}` 对象;\ + 流程表单是 `[{filedName,filedId,…}]` 数组 —— 后者不属于本引擎处理范围") +} + +/// 把解析结果组织成 `form.describe` 的输出。 +fn describe_json( + form: &sspf_lowcode::FormSchema, + row: Option<&Value>, + args: &Value, +) -> Value { + let main = form.main_fields(); + let subs = form.sub_tables(); + + let field_brief = |f: &sspf_lowcode::FieldNode| { + json!({ + "vModel": f.v_model, + "column": f.column_name(), + "label": f.label, + "jnpfKey": f.jnpf_key, + "widget": f.widget.as_str(), + "required": f.required, + "acceptsInput": f.widget.accepts_input(), + "visibility": f.visibility, + }) + }; + + let mut out = json!({ + "formRef": form.form_ref, + "formModel": form.form_model, + "labelPosition": form.label_position, + "labelWidth": form.label_width, + "primaryKeyPolicy": form.primary_key_policy, + "mainFields": main.iter().map(|f| field_brief(f)).collect::>(), + "subTables": subs.iter().map(|s| json!({ + "label": s.label, + "tableName": s.table_name, + "vModel": s.v_model, + "fields": s.children.iter() + .filter(|c| c.widget.occupies_column()) + .map(|c| field_brief(c)) + .collect::>(), + })).collect::>(), + "unknownWidgets": form.unknown_widgets().iter() + .map(|n| json!({"jnpfKey": n.jnpf_key, "label": n.label})) + .collect::>(), + "counts": { + "mainFields": main.len(), + "subTables": subs.len(), + }, + }); + + if let Some(r) = row { + out["id"] = r["id"].clone(); + out["fullName"] = r["fullName"].clone(); + out["enCode"] = r["enCode"].clone(); + out["type"] = r["type"].clone(); + out["state"] = r["state"].clone(); + } + + // 只有明确要求时才回原文(一张表单可能几十 KB) + if args.get("withRaw").and_then(Value::as_bool).unwrap_or(false) { + out["raw"] = form.raw.clone(); + } + + out } /// 去重并保持稳定顺序(BTreeSet 排序,避免每次调用结果顺序漂移)。 @@ -1887,6 +2170,11 @@ impl PlatformAdapter for NativeAdapter { "permission.effective" => self.permission_effective(&args).await, "permission.user.create" => self.user_create(&args).await, + // ------------------------------------------------ 低代码(P2-a,只读) + "form.list" => self.form_list(&args).await, + "form.describe" => self.form_describe(&args).await, + "form.validate" => self.form_validate(&args).await, + other => Err(ToolError::new( "OP_NOT_IMPLEMENTED", format!("原生适配器还没实现 op: {other}"), diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 217014a..a4ef34d 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -949,7 +949,10 @@ mod tests { 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"], 21); + // 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与 + // 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES + // + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。 + assert_eq!(body["tables"], 23); assert_eq!(body["version"], env!("CARGO_PKG_VERSION")); }