diff --git a/.workbuddy/memory/2026-10-31.md b/.workbuddy/memory/2026-10-31.md index 6cfb65a..160e798 100644 --- a/.workbuddy/memory/2026-10-31.md +++ b/.workbuddy/memory/2026-10-31.md @@ -703,3 +703,46 @@ Java `FlowFormDataUtil.create()` 里 `CALCULATE` 走 `getIntValue(dataValue, ... **修复**:在唯一开库入口 `open_db()`(src/backend/src/main.rs)开库前加 `#[cfg(unix)] ensure_stdout_for_pglite()` —— 若 fd 1 是字符设备或已关闭,把它 `dup2` 到一个匿名普通临时文件(`/tmp/ssw-pglite-stdout-.log`,进程级泄漏保活)。MCP 协议走 `dup` 出来的独立 fd,不受 fd1 改动影响。 **验证**:seed 四种重定向组合(file/file、/dev/null/file、file//dev/null、both//dev/null)全 EXIT=0 且无 pid 残留;MCP `1>/null 2>/null` EXIT=0 无残留;默认 HTTP `> /dev/null` EXIT=124(timeout) 无残留。`cargo test -p ssw-platform` 全量 0 failed。 + +--- + +## P2-b 收尾(21:13 自动续作) + +**做了什么** + +- `schema.table.create`(MCP 第 26 个业务工具):库内功能 `id/enCode` ⇒ 建表 + 回写 + `f_tables_data`;内联 `formData/tablesData` ⇒ 只能演练(`INLINE_REQUIRES_DRY_RUN`)。 + 写且幂等(表已存在跳 DDL、列不同报 `TABLE_EXISTS_DIFFERENT`)。`dryRun` 默认 true。 +- `mcp-smoke.sh` 32 → **48 条**:新增阶段 B(先 `--seed-lowcode-demo` 造 receivableDemo, + 再用同一 PGLITE_DIR 起 `--mcp`,python 动态驱动 —— 主键是服务端 UUID,静态 NDJSON 没法引用)。 + 覆盖 discover/describe、默认演练不落库、真写、data.query 查证、子表差集三类、删除、 + 同值不误拒、建表演练/幂等;M4 的「回复数=29」改成按请求文件计算。 +- `lowcode-smoke.sh` 8 → **15 条**:用 `schema.table.create` 内联演练钉建表规则 + (类型映射/dataLength、复合主键、逻辑删除三列、系统列视图类型),加两条反自证 + (logicalDelete=false 不加删除列;inline 不许落库)。 +- 文档:PLAN/CLAUDE/docs/mcp/docs/visualdev-mechanism 全部补 P2-b; + 工具数 21 → **26**(`tool_count_matches_doc` 测试钉死);清 `form.rs` / `sql.rs` 的 + `f_foreign_id` 漂移(真实外键列来自模型 `tableField`,如 `f_receivableid`)。 + +**顺手修的真问题**:`data.query {"table":"base_user"}` 会返回 `password` / `secretkey` +(红线⑤「口令不得外泄」被绕过)。修法:`SENSITIVE_COLUMNS` 白名单外禁止投影, +缺省滤掉并在结果里给 `hiddenColumns`,显式 `columns/where/orderBy` 要它 ⇒ `SENSITIVE_COLUMN`。 + +**T5 单租户交叉证据**(写进 visualdev-mechanism §10) + +- testspace `20-admin.yaml`:`MultiTenancy: false`(10-31 起),admin 只查 `j7`.`public` +- Java:`FlowFormDataUtil.addTenantId()` → `TenantDataSourceUtil.getTenantColumn()` + → `GlobalConst.DEFAULT_TENANT_VALUE = "0"` +- 官方手写 DDL `test_receivable`:`f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL` + 复合主键 +- 未做:30093 控制台人工抽查(需凭据,自动运行不索取) + +**T6 决定** + +- dry-run 返回真实参数值**不脱敏**(业务数据;dry-run 的意义就是核对真实值); + 口令列由投影层挡住,不靠脱敏 +- 子表 `modifyTime/modifyUser`:跟随表单控件;「更新时新增的子表行」按新增语义置 null + (Java 的 `childNeedAdd` 分支是跳过填充、保留入参 —— 刻意不同,审计更自洽,P4 对账忽略审计列) + +**数字**:`cargo test --workspace` **495** | mcp-smoke **48/48** | lowcode-smoke **15/15** +| 十二道闸门全绿(check-module 114、boundary 11、contract 10、citations 4、arch 9、naming 3+1提示、 +perm-smoke 43、perm-smoke-jnpf 23、baseline 10、mem 7 MB) diff --git a/.workbuddy/memory/automations/1dcb55af-5167-45b6-a1aa-93a0c2af2590/memory.md b/.workbuddy/memory/automations/1dcb55af-5167-45b6-a1aa-93a0c2af2590/memory.md new file mode 100644 index 0000000..ee00cb7 --- /dev/null +++ b/.workbuddy/memory/automations/1dcb55af-5167-45b6-a1aa-93a0c2af2590/memory.md @@ -0,0 +1,23 @@ +# 自动化执行记录 —— ssw-platform P2-b 收尾 + +## 2026-10-31 21:13(首次执行) + +**起点**:仓库干净,P2-b 内核 / 写工具 / seed 已在 `bcbe46c` 提交;T1/T2/T3/T4 的 +smoke 与工具化部分**未完成**(mcp-smoke 仍写死 29 条、lowcode-smoke 仍 8 条、 +`schema.table.create` 只有注释没有 ToolDef)。 + +**结果**:T1–T6 全部完成并提交。 + +- T3 `schema.table.create`:库内建表+回写;内联设计稿只允许演练。业务工具 25 → 26。 +- T1 `mcp-smoke.sh` 32 → 48 条:阶段 B 用种子 + python 动态驱动跑通写工具闭环。 +- T2 `lowcode-smoke.sh` 8 → 15 条:建表 DDL 四组规则 + 两条反自证。 +- T4 文档:PLAN / CLAUDE / docs/mcp / docs/visualdev-mechanism 补 P2-b;清 `f_foreign_id` 漂移。 +- T5 单租户:testspace `MultiTenancy: false` + Java `DEFAULT_TENANT_VALUE="0"` + 官方 DDL 三条互证。 + 线上控制台抽查未做(需凭据,无人值守不索取)。 +- T6:dry-run 参数**不脱敏**(业务值要可核对);顺手修 `data.query` 泄漏 `f_password` 的真问题; + 子表 modify 字段策略定为「跟随控件,新增行置 null」。 + +**验证**:cargo test --workspace 495;十二道闸门全绿(mcp-smoke 48、lowcode-smoke 15、 +baseline 10、perm 43/23、mem 7 MB)。 + +**遗留(P2-c)**:读 `base_visual_release`、单据号生成器(序号表)、真乐观锁。 diff --git a/CLAUDE.md b/CLAUDE.md index 1203bfd..f564f44 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -53,7 +53,7 @@ | 多租户 | `7.0-jnpf-java-tenant` / `f_tenant_id` | 单租户固定 `'0'`,暂不切分 | | SSO / OAuth | `jnpf-oauth`(`jnpf-oauth-api/-biz/-controller/-entity`) | 用内部账号密码会话 token,不做第三方登录 | | 微服务拆分 | `jnpf-public/jnpf-provider` | 单进程 monolith,不做 RPC/服务注册 | -| 低代码引擎 | `jnpf-flowable` / visualdev / 代码生成 | 官方能力,本期不碰 | +| 低代码引擎 | `jnpf-flowable` / visualdev / 代码生成 | **元数据引擎 + 动态 CRUD 已迁**(P2-a/P2-b,见 PLAN.md §P2);**流程引擎(flowable)与代码生成器仍不碰** | | 文件 / 消息 / AI / 调度 / 扩展 / 应用中心 | `jnpf-file` / `jnpf-message` / `jnpf-ai` / `jnpf-scheduletask` / `jnpf-extend` / `jnpf-app` | 后续按需,不在 v1;注意 Java 前端可能依赖文件上传等,Phase 2 验证时确认 | | 按钮/列/表单/数据范围级授权 | `base_module_button/_column/_form/_data` | 仅做 `item_type='module'`(菜单)一类 | @@ -213,8 +213,8 @@ ssw-platform/ | **静态·命名** | **`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 已绿** | +| **契约尺子·MCP** | **`scripts/mcp-smoke.sh`** | **48 条:4 元工具上限 / 分层加载 / 自提示 / 业务失败不误报协议错 / 结构注入防护 / 写工具校验 / 授权闭环 / prompts 模板 / stdout 纯 NDJSON + 阶段 B 低代码动态 CRUD(seed → 默认 dryRun 不落库 → 真写 → 查证 → 子表差集 → 删除 → 建表幂等 / 口令列不外泄)** | **48/48 已绿** | +| **契约尺子·低代码** | **`scripts/lowcode-smoke.sh`** | **15 条:真实样例解析 / 同构保序 / inline 校验 / 缺参拦截 / 建表 DDL 规则(类型映射·复合主键·逻辑删除列·系统列视图类型)+ 四条反自证** | **15/15 已绿** | | **契约尺子·双后端** | **`scripts/baseline-smoke.sh`** | **10 条:基线适配器自动登录 / health 裸对象 / 形状归一化(list→menus、organize→organizeId、裁剪多余键)/ 不支持的 op 发请求前拦下** | **10/10 已绿** | | **运行时·内存** | **`scripts/mem-budget.sh`** | **空载物理内存(vmmap `Physical footprint`)是否 ≤ 预算** | **7 MB / 40 MB 预算 已绿** | @@ -222,7 +222,7 @@ ssw-platform/ 每把尺子结尾比对「实际断言数 vs 契约登记数」,对不上即失败 —— 尺子不会被悄悄改弱。 **加任何业务模块 / 改任何契约 / 加任何 crate 依赖 / 改任何内部标识 / 加任何表,十二道闸门必须全绿才算完成。** -🔴 **`cargo test --workspace` 当前 344 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 45 + adapter-baseline 19 + lowcode 38 + 集成测试)—— +🔴 **`cargo test --workspace` 当前 495 条**(内核 + contract 13 + store 17 + sdk 2 + pack-asset 5 + mcp 52 + adapter-baseline 19 + lowcode 112 + 集成测试)—— 拆 crate 后总数会变,**不许把断言数写死**,跑一遍看实际值。 cipher 自证(免 node):`./target/release/ssw-platform --enc 123456`。 @@ -239,8 +239,11 @@ cipher 自证(免 node):`./target/release/ssw-platform --enc 123456`。 6. **平台层 / 业务层分离**:加模块只碰业务层;接线只在 `bootstrap.rs`。由 `check-boundary.sh` 钉死。 7. **判别头 `Vue-Version: 3`**:本仓前端禁止发该头(发了面 A 误判成面 B);面 B 必带。 8. **两套权限判据并存别混**:面 A 按菜单路径,面 B 按 `f_en_code`;同一用户两面可能一通一拒,不是 bug。 -9. **暂缓项不偷跑**:tenant / SSO / 微服务 / 低代码 不在本期(§2.2)。 +9. **暂缓项不偷跑**:tenant / SSO / 微服务 / 流程引擎 / 代码生成 不在本期(§2.2)。低代码**元数据 + 动态 CRUD** 已落地(P2-a/P2-b),但读 release / 单据号 / 乐观锁仍未做。 10. **同一文件多 Edit 必须串行 + 改完 grep 复核**。 +11. **低代码表必须「建表即回写」**:`schema.table.create`(或种子)建完表要回写 `f_tables_data`,否则 CRUD 层在模型里找不到 `f_delete_mark` ⇒ 逻辑删除直接报 `LOGICAL_DELETE_UNSUPPORTED`。 +12. **单租户也不省 `f_tenant_id`**:值恒为 `"0"`,但列 `NOT NULL` 且参与复合主键 `(f_id, f_tenant_id)`;建表/写入都必须带这一列。 +13. **写工具默认 `dryRun=true`**:新增写工具不传 `dryRun` 就是演练。这不只是防误写 —— 也是 AI 先看后写的唯一抓手。 --- @@ -273,7 +276,7 @@ cp .env.example .env && ./run.sh install && ./run.sh dev ```bash cargo build --release # 编译(workspace 根,含 crates/* 与 packs/*) -cargo test --workspace # 单测(当前 344 条) +cargo test --workspace # 单测(当前 495 条) bash run.sh dev # 起后端(30010) + 前端(5173) bash scripts/perm-smoke.sh # 面 A 43 条 bash scripts/perm-smoke-jnpf.sh # 面 B 23 条 @@ -284,8 +287,8 @@ bash scripts/check-arch.sh # crate 依赖纪律 AR1–AR7 + 内存红 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/mcp-smoke.sh # MCP 工具层契约 48 条(4 元工具 + 分层加载 + 授权闭环 + prompts + 低代码 CRUD) +bash scripts/lowcode-smoke.sh # 低代码 15 条(表单解析 + 校验 + 建表 DDL 规则 + 4 条反自证) 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/PLAN.md b/PLAN.md index 1b8d0d6..f4393cc 100644 --- a/PLAN.md +++ b/PLAN.md @@ -254,9 +254,9 @@ 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`** | -| 低代码元数据引擎 | 🟡 **P2-a 完成**:解析 + 校验 + 3 个只读工具 | visualdev 同构 + 动态 CRUD + 发布 | **动态 CRUD 待做(P2-b)** | +| 低代码元数据引擎 | ✅ **P2-b 完成**:解析 + 校验 + 建表 + 动态 CRUD(6 个工具) | visualdev 同构 + 动态 CRUD + 发布 | 读 release / 单据号 / 乐观锁 → P2-c | | 业务包格式 | 🟡 `pack.toml` 已定稿、`packs/asset` 已有样板 | 导入导出工具 | **P3** | -| MCP 工具面 | 🟡 **P1 主体完成**:4 元工具 + registry + 分层加载 + 双适配器 + 19 个业务工具 + 3 个流程模板 | 约 55 个业务工具(补 form/model/workflow) | P1 收尾 | +| MCP 工具面 | 🟡 **P1 主体完成**:4 元工具 + registry + 分层加载 + 双适配器 + 26 个业务工具 + 3 个流程模板 | 约 55 个业务工具(补 model/workflow/release) | P1 收尾 | | 影子对账 | ❌ 无 | 语料库 + 归一化比对 | **全新,P4** | | 部署形态 | 🟡 pglite 单二进制 | 单二进制 + 可选真实 PG | P5 收口 | @@ -867,9 +867,40 @@ tools/diff-harness/ - `scripts/lowcode-smoke.sh` 8 条,含**两条反自证**:改坏 `__vModel__` 必须被抓、未知控件必须只 warn **第一波刻意没做的**:动态 CRUD(写数据)、写表单定义。原因:写的前置是「解析 + 校验被真实数据验证透」, -否则等于让 AI 生成前端画不出来的 JSON。 +否则等于让 AI 生成前端画不出来的 JSON。**动态 CRUD 已在第二波补上,写表单定义仍未做。** -**P2-b 的前置件已完成**:`docs/visualdev-mechanism.md` —— 从 jnpf Java 源码逐条读出的运行时机制 +**P2-b 已完成(2026-10-31,第二波)—— 动态 CRUD 闭环**: + +- `sspf-lowcode::ddl`:**纯计算**建表 DDL(类型映射 / 复合主键 `(f_id, f_tenant_id)` / + 系统列 / 逻辑删除列)+ `rewrite_model`(把真实列回写成 `f_tables_data` 的形态) +- 内核 `lowcode_ddl::create_and_sync`:建表 → 回写 `f_tables_data`(**幂等**;表已存在则跳过, + 列不同报 `TABLE_EXISTS_DIFFERENT`,不自动 ALTER) +- 内核 `lowcode_crud` / `lowcode_check`:真实事务执行、子表差集对账、 + **落库前三重校验**(单行唯一 `UNIQUE_CONSTRAINT_VIOLATED` / 业务主键组合唯一 + `BUSINESS_KEY_VIOLATED` / 必填,失败一条 SQL 都不执行) +- MCP 工具 4 个(写):`schema.table.create` + `data.record.insert/update/delete`; + 写工具**默认 `dryRun=true`**(不传就是演练) +- 开发期通道 `--seed-lowcode-demo [--dry-run]`:用官方 fixture 造一份可用的低代码功能 + (固定 `enCode=receivableDemo`,幂等;prod 档开库前拒绝;dry-run 连库都不开) +- `scripts/mcp-smoke.sh` 扩到 **48 条**(M1–M47,其中阶段 B 用 python 动态驱动, + 覆盖「演练不落库 → 真写 → 查证 → 子表差集 → 删除」) +- `scripts/lowcode-smoke.sh` 扩到 **15 条**(L9–L14:类型映射 / 复合主键 / 逻辑删除列 / + 系统列视图类型,含两条反自证) + +**P2-b 的关键判断(后续别改坏)**: + +1. **建表后必须回写** `f_tables_data`:不回写 ⇒ CRUD 层在模型里找不到 `f_delete_mark`, + 逻辑删除直接报 `LOGICAL_DELETE_UNSUPPORTED`(已真实踩到)。 +2. 建表列来源 = **模型**(不是表单控件):官方 `f_tables_data` 本身就是建表后的回写产物, + 列序与官方 DDL 逐列一致;模型驱动少一层「控件类型 ↔ DDL 类型」的多对一映射。 +3. `f_delete_mark` 是 **INTEGER**,不是 boolean(官方 `TableFeildsEnum` 也是 `"int"`)。 +4. **单租户**:`f_tenant_id` 固定 `"0"`,但列 `NOT NULL` 且**参与复合主键** —— 不能省。 +5. 子表更新是**差集对账**(不是整条替换):入参没有的旧行会被删;主表则是部分更新。 + +**P2-b 刻意没做的**(留给 P2-c):读 `base_visual_release`(运行时读发布版)、 +单据号生成器(需序号表)、真正的乐观锁(现在只写 `f_version=0`,不校验)。 + +**P2-b 的前置件**:`docs/visualdev-mechanism.md` —— 从 jnpf Java 源码逐条读出的运行时机制 (接口契约 15 个端点 / 列名规则 / 系统字段 / 自动填充 / 主子表),每条结论标了源码位置。 读这份文档时纠正了两个已实现代码里的错误判断(列名归因反了、`calculate` 不是只读)。 @@ -877,7 +908,8 @@ tools/diff-harness/ 1. `f_tables_data` 的 `columnName` **全是 null** ⇒ 只能从 `field` 推导,而推导**不等于**真实列名 (`F_CreatorTime` → `f_creatortime`,实际列是 `f_creator_time`) - ⇒ 本 crate 只保证「表单 ↔ 模型设计稿」自洽;与真实库的一致性要拿 `information_schema` 比(P2-b) + ⇒ 本 crate 只保证「表单 ↔ 模型设计稿」自洽;与真实库的一致性由 P2-b 的写工具在落库前比对 + `information_schema`(对不上报 `COLUMN_MISMATCH`,拒绝写) 2. 子表内字段的 `tableName` 指向**主表**,不是子表 ⇒ 子表归属只能看父节点 3. `formRef` / `formModel` 是 Vue 变量名,不是固定常量(见过 `elForm`/`formData`,也见过 `formRef`/`dataForm`) diff --git a/crates/sspf-lowcode/src/sql.rs b/crates/sspf-lowcode/src/sql.rs index d547412..2e7254d 100644 --- a/crates/sspf-lowcode/src/sql.rs +++ b/crates/sspf-lowcode/src/sql.rs @@ -19,7 +19,7 @@ //! | 空数组 → NULL | `valueToNull()`:空 List → null | //! | 主表 `f_flow_task_id` = 主键 | `createMast()`:`set(flowTaskId).toValue(mainId.toString())` | //! | 主键列名取模型里 `primaryKey=1` 的列,否则 `f_id` | `getKey()` | -//! | 子表 `f_foreign_id` = 主表主键 | `createMastTable()` | +//! | 子表外键列 = 模型的 `tableField`(**不是** `f_foreign_id`) | `createMastTable()` | //! | 列表值 → JSON 字符串 | `createMast()`:`data instanceof List ? JsonUtil.getObjectToString(data)` | //! | 系统字段不被入参覆盖 | `create()` 的 switch 分支 | //! diff --git a/crates/sspf-mcp/src/tools/form.rs b/crates/sspf-mcp/src/tools/form.rs index 31c751e..0d4f7ef 100644 --- a/crates/sspf-mcp/src/tools/form.rs +++ b/crates/sspf-mcp/src/tools/form.rs @@ -7,7 +7,9 @@ //! 就开放写入,等于让 AI 生成一堆前端画不出来的 JSON。 //! //! ⇒ P2-a 只做三件事:**列出来、看懂它、指出它哪里不自洽**。 -//! 动态 CRUD(写数据)在 P2-b,写表单定义在 P2-c。 +//! 动态 CRUD(写数据)已在 **P2-b 落地**:`schema.table.create` 建表, +//! `data.record.insert/update/delete` 写数据(见 `tools/lowcode.rs`)。 +//! 写表单定义(`f_form_data` 的生成)仍在 P2-c。 //! //! ## 为什么 `form.validate` 是最有价值的那个 //! @@ -199,7 +201,8 @@ pub const FORM_VALIDATE: ToolDef = ToolDef { right: "ok=true 只代表**设计稿自洽**;与真实数据库列的一致性还没验", rationale: "本校验比对的是「表单 __vModel__ 推导出的列」与「模型 field 推导出的列」,\ 两边用同一套推导 ⇒ 只证明设计稿内部一致。真实列名要以\ - information_schema 为准(P2-b 会补这一步)。", + information_schema 为准 —— P2-b 的写工具在落库前会做这一步\ + (对不上报 COLUMN_MISMATCH,拒绝写)。", }, Pitfall { severity: Severity::P1, diff --git a/crates/sspf-mcp/src/tools/lowcode.rs b/crates/sspf-mcp/src/tools/lowcode.rs index 0a6c96f..0524891 100644 --- a/crates/sspf-mcp/src/tools/lowcode.rs +++ b/crates/sspf-mcp/src/tools/lowcode.rs @@ -9,10 +9,17 @@ //! //! | 工具 | 动作 | 对齐的基线平台方法 | //! |---|---|---| +//! | `schema.table.create` | 按设计稿建物理表 + 回写模型 | `VisualDevTableCre.tableList()` / `DbTableServiceImpl.createTable()` | //! | `data.record.insert` | 新增一条(含子表) | `FlowFormDataUtil.create()` | //! | `data.record.update` | 更新一条(含子表差集对账) | `FlowFormDataUtil.update()` | //! | `data.record.delete` | 删除一条(逻辑/物理) | `FlowFormDataUtil.deleteTable()` | //! +//! ## 🔴 建表是 CRUD 的**前置**,不是可选项 +//! +//! 低代码功能的表不会自己出现 —— 先 `schema.table.create`, +//! 才有 `data.record.*` 能写的那张表。建完必须回写 `f_tables_data`(工具内部做), +//! 否则 CRUD 层在模型里找不到系统列(逻辑删除会报 `LOGICAL_DELETE_UNSUPPORTED`)。 +//! //! ## 🔴 三条与「普通写工具」不同的约定 //! //! 1. **设计稿 vs 真实库必须一致**:落库前拿 `information_schema` 比一遍列, @@ -265,6 +272,80 @@ pub const DATA_RECORD_DELETE: ToolDef = ToolDef { handler: record_delete_handler, }; +// ================================================================ schema.table.create + +passthrough!(schema_table_create_handler, "schema.table.create"); + +pub const SCHEMA_TABLE_CREATE: ToolDef = ToolDef { + id: "schema.table.create", + category: Category::Schema, + title: "按设计稿建低代码表", + one_liner: "按低代码设计稿建表并回写模型(默认只演练)", + input_schema: r#"{ + "type": "object", + "properties": { + "id": { "type": "string", "description": "功能 id(查库取设计稿)" }, + "enCode": { "type": "string", "description": "或功能编码(查库取设计稿)" }, + "formData": { "type": "string", "description": "内联设计稿:表单 JSON 字符串;与 tablesData 同时给,且只能 dryRun" }, + "tablesData": { "type": "string", "description": "内联设计稿:模型 JSON 字符串;与 formData 同时给" }, + "dryRun": { "type": "boolean", "default": true, "description": "true=只出 DDL 与回写后的模型,不建表、不回写" } + }, + "additionalProperties": false + }"#, + annotations: Annotations::UPSERT, + hints: Hints { + when_to_use: &[ + "低代码功能刚设计完,库里还没有表", + "data.record.* 报 TABLE_NOT_IN_DB(表没建)", + "改完设计稿要看新 DDL 长什么样(dryRun)", + ], + when_not_to_use: &[ + "只是想看已有的表(用 schema.table.list / describe)", + "表已经对了,只是模型落后(重跑一次本工具即会幂等回写)", + "要改已有表的列(本工具不迁移,会报 TABLE_EXISTS_DIFFERENT)", + ], + preconditions: &[ + "功能的 f_form_data 与 f_tables_data 都存在(否则先补设计稿)", + "模型里至少有一列 primaryKey=1,否则建不出主键", + "只有 dev 档能真建表(生产档拒绝)", + ], + pitfalls: &[ + Pitfall { + severity: Severity::P0, + wrong: "以为 dryRun 也把模型回写了,接着直接调 data.record.insert", + right: "dryRun 什么都不写;要落库得显式 dryRun=false,它会建表**并**回写 f_tables_data", + rationale: "回写是 CRUD 的前提:模型里没有系统列(f_tenant_id / f_delete_mark),\ + 逻辑删除会报 LOGICAL_DELETE_UNSUPPORTED,列比对也永远对不上。", + }, + Pitfall { + severity: Severity::P0, + wrong: "改了设计稿就直接重跑,以为会自动 ALTER 表", + right: "列结构对不上会报 TABLE_EXISTS_DIFFERENT —— 本工具只建不改", + rationale: "基线平台 createTable() 也是「存在即返回」。\ + 自动改表在生产里等于无声迁移,比报错危险得多。", + }, + Pitfall { + severity: Severity::P1, + wrong: "用内联 formData/tablesData 传 dryRun=false", + right: "内联只能演练:没有功能记录可回写,落库会得到 INLINE_REQUIRES_DRY_RUN", + rationale: "建表必须和「哪条功能定义」绑定 —— 回写目标不明确时建出来的表\ + 没人认领,等于给库里留垃圾。", + }, + ], + examples: &[ + Example { + args: r#"{"enCode":"receivableDemo","dryRun":true}"#, + note: "先看 DDL", + }, + Example { + args: r#"{"enCode":"receivableDemo","dryRun":false}"#, + note: "确认后建表 + 回写模型", + }, + ], + }, + handler: schema_table_create_handler, +}; + /// P2-b 的低代码写工具(3 个)。 pub static LOWCODE_TOOLS: &[ToolDef] = &[ DATA_RECORD_INSERT, @@ -272,6 +353,9 @@ pub static LOWCODE_TOOLS: &[ToolDef] = &[ DATA_RECORD_DELETE, ]; +/// P2-b 的建表工具(1 个)—— CRUD 的前置件,写且幂等(表已存在则跳过)。 +pub static LOWCODE_DDL_TOOLS: &[ToolDef] = &[SCHEMA_TABLE_CREATE]; + #[cfg(test)] mod tests { use super::*; @@ -323,6 +407,28 @@ mod tests { } } + /// 🔴 建表工具:写 + 幂等,且必须带 dryRun。 + #[test] + fn ddl_tool_is_idempotent_and_dry_runnable() { + let t = &LOWCODE_DDL_TOOLS[0]; + assert!(!t.annotations.read_only, "建表是写操作"); + assert!(t.annotations.idempotent, "表已存在应跳过(幂等)"); + assert!( + t.schema_value()["properties"]["dryRun"].is_object(), + "建表工具必须有 dryRun" + ); + } + + /// 🔴 建表工具的参数白名单 —— 同样不许「声明了但没实现」。 + #[test] + fn ddl_tool_declares_only_implemented_parameters() { + const ALLOWED: &[&str] = &["id", "enCode", "formData", "tablesData", "dryRun"]; + let s = LOWCODE_DDL_TOOLS[0].schema_value(); + for key in s["properties"].as_object().expect("properties").keys() { + assert!(ALLOWED.contains(&key.as_str()), "未实现的参数:{key}"); + } + } + /// 🔴 **schema 里不许出现「声明了但没实现」的参数**。 /// /// 这不是洁癖 —— 是**行为契约**:AI 看到 `idempotent` 就会以为 diff --git a/crates/sspf-mcp/src/tools/mod.rs b/crates/sspf-mcp/src/tools/mod.rs index 76a7aa6..6ee9613 100644 --- a/crates/sspf-mcp/src/tools/mod.rs +++ b/crates/sspf-mcp/src/tools/mod.rs @@ -184,9 +184,18 @@ 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)+ 第五批 3 个低代码读取 -/// = **21 个**。后续按 `PLAN.md` §6.3 的 12 域补齐到约 55 个。 +/// | 批次 | 数量 | 内容 | +/// |---|---|---| +/// | P1-a 首批 | 4 | context / schema ×2 / menu | +/// | P1-b 只读 | 8 | permission ×3 / dict ×2 / data ×2 / schema ×1 | +/// | P1-c 写 | 3 | menu ×2 / dict ×1 | +/// | P1-d 授权闭环 | 4 | grant / revoke / effective / user.create | +/// | P2-a 低代码读 | 3 | form.list / describe / validate | +/// | P2-b 低代码写 | 4 | schema.table.create + data.record.insert / update / delete | +/// +/// 合计 **26 个**。后续按 `PLAN.md` §6.3 的 12 域补齐到约 55 个。 +/// +/// 🔴 改这个数组就要同步改这一行数字 —— `tool_count_matches_doc` 会钉住它。 pub static ALL_TOOLS: &[ToolDef] = &[ // —— 首批(P1-a)—— CONTEXT_GET_TOOL, @@ -216,6 +225,7 @@ pub static ALL_TOOLS: &[ToolDef] = &[ form::FORM_DESCRIBE, form::FORM_VALIDATE, // —— 第六批(P2-b):低代码动态 CRUD(写,带 dry_run)—— + lowcode::SCHEMA_TABLE_CREATE, lowcode::DATA_RECORD_INSERT, lowcode::DATA_RECORD_UPDATE, lowcode::DATA_RECORD_DELETE, @@ -255,6 +265,16 @@ mod tests { } } + /// 🔴 工具总数与上面的文档表**必须一致** —— 文档漂移只有机器能钉住。 + #[test] + fn tool_count_matches_doc() { + assert_eq!( + ALL_TOOLS.len(), + 26, + "ALL_TOOLS 数量变了:同步改 `ALL_TOOLS` 的文档表、PLAN.md 与 docs/mcp.md" + ); + } + /// 工具 id 必须唯一(重复注册会让 describe 拿到错的那个)。 #[test] fn tool_ids_are_unique() { diff --git a/docs/mcp.md b/docs/mcp.md index 536a257..6c155b7 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -80,7 +80,7 @@ sspf_context # 1. 先确认环境 → 失败则读 error.hints / next_actions 自纠 ``` -### 当前业务工具(22 个) +### 当前业务工具(26 个) | 域 | 工具 | 一句话 | 写 | |---|---|---|---| @@ -88,6 +88,7 @@ sspf_context # 1. 先确认环境 | schema | `schema.table.list` | 列出物理表 | | | schema | `schema.table.describe` | 看表的列与类型 | | | schema | `schema.index.list` | 索引与唯一约束 | | +| schema | `schema.table.create` | 按低代码设计稿建表 + 回写模型 | ✅ | | menu | `menu.tree` | 菜单树(按应用隔离) | | | menu | `menu.create` | 建菜单(写全 enCode + systemId) | ✅ | | menu | `menu.delete` | 软删菜单 | ✅ | @@ -103,6 +104,9 @@ sspf_context # 1. 先确认环境 | dict | `dict.type.create` | 建字典分类 | ✅ | | data | `data.query` | 按表名查数据(结构化条件) | | | data | `data.count` | 按表名计数 | | +| data | `data.record.insert` | 按设计稿新增记录(主表 + 子表) | ✅ | +| data | `data.record.update` | 按设计稿更新(子表差集对账) | ✅ | +| data | `data.record.delete` | 删记录(逻辑/物理按功能设置) | ✅ | | form | `form.list` | 列低代码功能(`base_visual_dev`) | | | form | `form.describe` | 解析表单:主表字段/子表/控件类型 | | | form | `form.validate` | 校验表单声明的字段在表里是否真有列 | | @@ -111,6 +115,11 @@ sspf_context # 1. 先确认环境 所以写工具都在写库**之前**做完校验(必填/格式/父节点存在/编码唯一), 并给出可执行的 `hints`;删除一律软删。 +🔴 **`data.query` 不投影口令 / 密钥列**(`f_password` / `f_secretkey`): +缺省投影会跳过它们并在结果里返回 `hiddenColumns`(藏了几列); +显式在 `columns` / `where` / `orderBy` 里要它们 ⇒ `SENSITIVE_COLUMN`。 +要用户信息请用 `permission.user.list`(它本来就不返回口令字段)。 + 🔴 **`menu.create` 比 HTTP 侧的 `module_save` 更完整**:后者只写 12 列,缺 `f_en_code`(面 B 权限判据)与 `f_system_id`(多应用隔离)——那两列缺了, 菜单要么点进去 403,要么根本不显示。P2 元数据引擎统一时会把两处合成一处。 @@ -181,7 +190,73 @@ jnpf 建表时原样写 vModel,PG/Kingsbase 再 `toLowerCase()`。 **`form.validate` 只保证「设计稿自洽」,不等于「表已经建好了」**: 它比对表单推导的列与模型 `field` 推导的列(两边同一套规则,所以能验出「表单引用了模型里没有的字段」)。 -但库里到底有没有这张表、列够不够,要拿 `information_schema` 比 —— P2-b 补。 +但库里到底有没有这张表、列够不够,要拿 `information_schema` 比 —— +这一步由 P2-b 的写工具在**落库前**做(对不上报 `COLUMN_MISMATCH` / `TABLE_NOT_IN_DB`,拒绝写)。 + +### 低代码动态 CRUD(P2-b) + +``` +schema.table.create(dryRun) 先看要建的 DDL 与回写后的模型 + → schema.table.create 建表 + 回写 f_tables_data(幂等) + → data.record.insert(dryRun) 看 SQL 与参数 + → data.record.insert 落库 + → data.query 查证 + → data.record.update 改主表字段 / 子表差集对账 + → data.record.delete 删(逻辑或物理,按功能的 logicalDelete) +``` + +**建表不是可选项**:低代码功能的表不会自己出现。`data.record.*` 直接写一张不存在的表 +会报 `TABLE_NOT_IN_DB` —— 这时先 `schema.table.create`。 + +🔴 **建表后必须回写 `f_tables_data`**(工具内部做,`dryRun=false` 时)。 +不回写的后果不是「少一列」这么轻:CRUD 层在**模型**里找 `f_delete_mark`, +找不到就报 `LOGICAL_DELETE_UNSUPPORTED`;而且「设计稿 vs 真实库」的列比对永远对不上。 +基线平台 `VisualDevTableCre.tableList()` 建完表也是把装配后的 `TableModel` 写回 `f_tables_data`。 + +`schema.table.create` 支持两种输入: + +| 模式 | 入参 | 能落库吗 | +|---|---|---| +| 查库 | `id` / `enCode` | ✅ `dryRun=false` 建表 + 回写 | +| inline | `formData` + `tablesData` | ❌ 只能演练(`INLINE_REQUIRES_DRY_RUN`)—— 没有可回写的功能记录 | + +**子表更新是差集对账,不是整条替换**(与主表的部分更新语义不同): + +| 情况 | 动作 | +|---|---| +| 入参行的主键在库里 | `updateSub` | +| 入参行的主键不在库里 | `insertSub` | +| 库里有、入参没有 | 删除(`logicalDelete` 开则 `softDelete`,否则 `hardDelete`) | + +🔴 因此「只改子表一行的某个字段」也必须把**这张子表的所有行**都传进来, +否则没传的旧行会被删掉。只想追加不改动,就先把现有行查出来一起传。 + +**三道落库前校验**(都对齐基线平台,失败时一条 SQL 都不执行): + +| 校验 | 触发条件 | 错误码 | +|---|---|---| +| 单行唯一 | 控件 `unique=true` 且是普通输入 | `UNIQUE_CONSTRAINT_VIOLATED` | +| 业务主键组合唯一 | 表单 `useBusinessKey=true` | `BUSINESS_KEY_VIOLATED` | +| 必填 | 控件 `required=true` | `MISSING_REQUIRED` | + +查重只算**未删除**的行(`f_delete_mark=0` 或该列不存在);更新时排除自己。 + +**写工具默认 `dryRun=true`**(不传就是演练)。dry-run 会返回完整 SQL 与参数 —— +这是刻意的:AI 要先能看清「到底写什么」,才谈得上让人放心让它写。 +返回值里不含任何口令字段(适配器层就不投影这类列);业务数据本身**不做脱敏** —— +dry-run 的意义就是让人核对真实值,遮掉反而看不出写错在哪。 + +### 造一份示例功能:`--seed-lowcode-demo` + +```bash +PGLITE_DIR=/tmp/sspf-demo ./target/debug/ssw-platform --seed-lowcode-demo # 建表 + 写功能定义 +PGLITE_DIR=/tmp/sspf-demo ./target/debug/ssw-platform --seed-lowcode-demo --dry-run # 只看不碰库(连库都不开) +``` + +- 固定 `id=lowcode-demo-receivable` + `enCode=receivableDemo` ⇒ **幂等**(重复跑是更新同一条) +- 数据来源是**官方 fixture**(基线初始化数据里的「应收费用」)⇒ 种出来的库就是真实低代码功能的样子 +- 只在 dev 档可用:`SSW_PROFILE=prod|production` 在**开库前**就拒绝(它会建表) +- 种完可以立刻 `data.record.insert {"enCode":"receivableDemo",...}` 端到端试写 --- @@ -278,12 +353,17 @@ cargo run -p sspf-adapter-baseline --example probe -- \ --- -## 5. 已知限制(P1 阶段) +## 5. 已知限制(P2-b 收尾时点) | 限制 | 说明 | 计划 | |---|---|---| | 没有登录态 | 进程内适配器是**管理员视角**,绕过菜单守卫 | 刻意如此(本地开发);对外暴露必须换 `BaselineHttpAdapter` | -| 业务工具 19 个 | 见上面清单;form / model / workflow 还没有 | P2 补 | +| 业务工具 26 个 | 见上面清单;model / workflow / release 域还没有 | P3 补 | +| 读的是 `base_visual_dev`,不是 release | 只读工具与动态 CRUD 都取草稿表;发布快照 `base_visual_release` 只有种子在写 | 运行时读 release 待补(P2-c) | +| 单据号生成器未做 | `billRule` 控件不接收入参,但**也不会自动生成**(需序号表);入参给了 `billRule` 字段会被忽略 | 序号表 + 规则引擎(P2-c) | +| 没有乐观锁 | `concurrencyLock=true` 时插入会写 `f_version=0`,但更新**不校验**版本 | 真并发控制(P3) | +| 建表只建不改 | 表已存在且列不同 ⇒ `TABLE_EXISTS_DIFFERENT`,不自动 ALTER | 刻意:自动迁移比报错危险 | +| `schema.table.create` 只在 dev 档建表 | 生产档拒绝(会改库结构) | 刻意 | | 基线适配器只支持 5 个只读 op | baseline 无元数据 API | P4 按对账需要再补 | | 基线适配器只支持 `http://` | 未引入 TLS 栈;`https://` 构造期直接报错 | 需要时再加 | | `permission.user.create` 不开放建管理员 | `isAdministrator` 硬编码 false | 刻意:避免 AI 顺手造超管 | diff --git a/docs/visualdev-mechanism.md b/docs/visualdev-mechanism.md index 7dbff87..6e24ad0 100644 --- a/docs/visualdev-mechanism.md +++ b/docs/visualdev-mechanism.md @@ -2,7 +2,8 @@ > **这份文件解决什么问题**:`PLAN.md` 第 4 条要求「以 jnpf 源码迁移,数据库脚本一致, > API 调用/行为一致」。要做到「行为一致」,必须先知道**原平台到底怎么跑**。 -> 本文件是从 Java 源码逐条读出来的机制,是 P2-b(动态 CRUD)的实施依据。 +> 本文件是从 Java 源码逐条读出来的机制。P2-a/P2-b 已按它落地(`sspf-lowcode` + `data.record.*`), +> §9 是「机制 ↔ 实现」的对照表;后续阶段(读 release / 单据号 / 乐观锁)仍以本文为准。 > > **每条结论都标了源码位置**,改代码前先回来核对,别凭印象。 @@ -156,7 +157,9 @@ if (logicalDelete) { } ``` -子表额外多一个外键列 `f_foreign_id`(指向主表主键)。 +子表额外多一个**外键列**,列名来自模型的 `tableField` —— 实测 `test_details` 是 +`f_receivableid`(不是常量 `f_foreign_id`)。`f_foreign_id` 是早期猜测,已在 +`sspf-lowcode/src/sql.rs` 与建表模块里按真实数据纠正。 字段名常量见 `$SRC/jnpf-common/jnpf-boot-common/jnpf-common-core/src/main/java/jnpf/constant/TableFieldsNameConst.java`。 @@ -171,6 +174,36 @@ if (logicalDelete) { ⇒ 看到 `f_creator_time` 样式不要以为规律统一了 —— 那多半是控件叫 `F_Creator_Time`。 +### 🔴 生成 DDL 的口径:**模型驱动**(Java 是表单驱动) + +| | jnpf `VisualDevTableCre` | 本仓 `sspf-lowcode::ddl` | +|---|---|---| +| 列来源 | **表单控件**(`FieLdsModel`)+ 追加系统列 | **模型 `f_tables_data`** + 补齐缺失的系统列 | +| 列序 | 控件顺序 + 系统列在后 | 模型顺序(= 官方回写后的真实列序) | +| 类型/长度 | 按控件类型与 `dataType` 配置推 | 按模型 `dataType` / `dataLength` 直接映射 | +| 适用场景 | 第一次建表(只有设计稿) | 设计稿已含模型(官方数据的常态) | + +为什么可以不照抄表单驱动:库里真实的 `f_tables_data` 本来就是**建表之后回写**的产物 +(`entity.setVisualTables(...)`),列序与官方 DDL 逐列一致 —— 再拿表单控件反推一遍 +只会多一层「控件类型 ↔ DDL 类型」的多对一映射,反而容易错。 +前置条件是 **模型与表单自洽**,这由 `form.validate` 负责(列集合对不上会报 `COLUMN_NOT_IN_TABLE`)。 + +### 🔴 DEFAULT 差异:动态建表 vs 官方手写 SQL + +| 列 | Java 动态建表 | 官方手写 `jnpf_db_init.sql` | +|---|---|---| +| `f_tenant_id` | `VARCHAR(50) DEFAULT '0' NOT NULL` | 同(有 DEFAULT) | +| `f_version` | `INTEGER DEFAULT '0'` | `INTEGER`(**没有** DEFAULT) | +| `f_flow_state` | `INTEGER DEFAULT '0'` | `INTEGER`(**没有** DEFAULT) | + +原因:`ConcurrencyUtils.getDbFieldModel()` 对 TENANTID / FLOWSTATE / VERSION 设了 +`defaultValue="0"`,`FormatSql.defaultCheck()` **所有类型都加引号** ⇒ 输出 `DEFAULT '0'`。 +官方初始化脚本是**手写**的,不是这条链路的产物,所以没有 DEFAULT。 + +⇒ 本仓生成的是「Java 动态建表」的结果(带 DEFAULT)。语义等价(PG 里 +`INTEGER DEFAULT '0'` 合法,字符串常量会转成目标类型),但**逐字对比官方脚本时会看到差异** —— +这不是 bug,是两条不同来源的 DDL。 + --- ## 5. 主键与流程字段 @@ -214,6 +247,24 @@ GeneralInsertDSL dsl = insertInto(sqlTable) 把它当只读会导致「计算字段永远存不进去」。 2. **被覆盖的字段不能标 `acceptsInput`** —— 否则调用方以为传了有用,实际被丢弃。 +### 🔴 子表 `modifyTime` / `modifyUser` 策略(已定,刻意与 Java 有一处差异) + +**口径:自动填充跟随表单控件** —— 表单里有 `modifyTime` / `modifyUser` 控件才写, +没有这个控件就不写(列可以存在,但没人填)。 + +| 场景 | Java | 本仓 | +|---|---|---| +| 新增(主表 / 子表) | 置 `null` | 置 `null`(一致) | +| 更新(主表 / 子表已有行) | 写当前时间 / 当前用户 | 写当前时间 / 当前用户(一致) | +| **更新时新增的子表行** | `childNeedAdd=true` ⇒ **跳过**填充,保留入参值 | 按「新增」语义置 `null` | + +最后一处是**刻意**的:让调用方能给新子行伪造 `modifyUser` / `modifyTime` 没有好处, +而「新行没有修改人」在审计上自洽。差异只落在审计列,不碰业务列 —— +P4 影子对账时按「忽略审计列」处理即可。 + +> 代码落点:`crates/sspf-lowcode/src/sql.rs::sub_row_columns`(`is_update` 分支) +> 测试钉死:`update_writes_modify_time_and_modify_user` / `insert_nulls_modify_time_and_modify_user` + > 代码落点:`crates/sspf-lowcode/src/widget.rs::auto_fill` / `AutoFill` > 测试钉死:`auto_fill_matches_jnpf_create_switch` / `overridden_fields_do_not_accept_input` @@ -224,7 +275,7 @@ GeneralInsertDSL dsl = insertInto(sqlTable) `createTable()` 与 `createMast()` 的差别: - 子表数据来自**父节点**的 `__config__.children`,写到 `__config__.tableName` 指定的表 -- 每行由服务端生成自己的 `f_id`,并把 **`f_foreign_id` = 主表 id** +- 每行由服务端生成自己的 `f_id`,外键列(模型 `tableField`,如 `f_receivableid`)= 主表 id - 🔴 子表内字段**自身的 `tableName` 不可信**:实测指向的是主表 > 代码落点:`crates/sspf-lowcode/src/form.rs::sub_tables`(只看父节点) @@ -248,26 +299,48 @@ GeneralInsertDSL dsl = insertInto(sqlTable) | 机制 | 状态 | 落点 | |---|---|---| | 列名 = `lower(vModel)` | ✅ 已对齐 | `form::v_model_to_column` | -| 系统字段清单 | ✅ 已记录 | 本文件 §4 | +| 系统字段清单 | ✅ 已对齐 | 本文件 §4 / `ddl::SystemColumn` | | 自动填充表 | ✅ 已对齐 | `widget::auto_fill` | | 控件分类(54 种) | ✅ 已覆盖实测 top 12 | `widget::classify` | | 子表归属看父节点 | ✅ 已对齐 | `form::sub_tables` | -| 读 release 而非 dev | 🟡 只读工具读的是 **dev** | P2-b 要补 release 读取 | -| 动态 CRUD(写数据) | ❌ 未做 | P2-b | -| `f_flow_task_id` = 主键 | ❌ 未做 | P2-b | -| 单据号生成器 | ❌ 未做 | P2-b(需序号表) | -| 并发锁 `f_version` | ❌ 未做 | P2-b | -| 逻辑删除 | ❌ 未做 | P2-b | +| 建表 DDL(类型映射/复合主键/系统列) | ✅ 已对齐 | `ddl::plan_create` + `rewrite_model` | +| 建表后回写 `f_tables_data` | ✅ 已对齐 | `lowcode_ddl::create_and_sync` | +| 动态 CRUD(写数据) | ✅ 已对齐 | `lowcode_crud` + `data.record.*` | +| `f_flow_task_id` = 主键 | ✅ 已对齐 | `sql::main_guard.flow_task_id` | +| 逻辑删除 | ✅ 已对齐(`f_delete_mark` 是 INTEGER) | `sql::soft_delete_row` | +| 读 release 而非 dev | 🟡 只读工具读的是 **dev** | 运行时读 release 待补(P2-c) | +| 单据号生成器 | ❌ 未做(需序号表);`billRule` 入参不被覆盖已实现 | P2-c | +| 并发锁 `f_version` | 🟡 只写初值 0,**不校验**版本 | 真乐观锁待补(P3) | --- -## 10. 复核方法 +## 10. 单租户口径的交叉证据 + +「`f_tenant_id` 固定 `'0'`」不是约定俗成,有三条独立证据: + +| 证据 | 内容 | +|---|---| +| 部署配置 | `jnpf-k8s/k8s/20-admin.yaml` 的 `config.MultiTenancy: false`(2026-10-31 起)⇒ admin 只查 `j7` 库的 `public` schema;登录账号**不带**租户号;`jnpf-tenant` 服务仍在跑但已成孤儿 | +| Java 代码链 | `FlowFormDataUtil.addTenantId()` → `TenantDataSourceUtil.getTenantColumn()` → 多租户关闭时返回 `GlobalConst.DEFAULT_TENANT_VALUE`,其值就是 `"0"` | +| 官方手写 DDL | `test_receivable`:`f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL` + `PRIMARY KEY (f_id, f_tenant_id)` | + +⇒ 单租户下 `f_tenant_id` **恒为 `"0"`**,且这一列 `NOT NULL` 并参与复合主键 —— +即使只有一个租户也不能省略。本仓 `DEFAULT_TENANT_ID = "0"`、建表生成 +`f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL`,与上表逐字对得上。 + +⚠️ **未做的人工核对**:JNPF 完整部署(`http://192.168.1.26:30093/`)里动态表的 +`f_tenant_id` 实际分布没抽查 —— 需要登录凭据(本次自动运行未提供,按约定不入档)。 +要核:`SELECT f_tenant_id, count(*) FROM test_receivable GROUP BY 1`,或多建几条记录看是否为 `0`。 + +--- + +## 11. 复核方法 改任何与「列名 / 系统字段 / 自动填充」相关的代码前,重跑这几条: ```bash -cargo test -p sspf-lowcode # 40 条,含列名与自动填充的对齐断言 -bash scripts/lowcode-smoke.sh # 8 条,含反自证 +cargo test -p sspf-lowcode # 112 条,含列名 / 自动填充 / 建表 DDL 的对齐断言 +bash scripts/lowcode-smoke.sh # 15 条,含 4 条反自证(L6/L7/L13/L14) ``` 源码复核入口(按重要性): diff --git a/scripts/lowcode-smoke.sh b/scripts/lowcode-smoke.sh index c32e912..d97f43d 100755 --- a/scripts/lowcode-smoke.sh +++ b/scripts/lowcode-smoke.sh @@ -12,7 +12,15 @@ # L7 🔴 反自证:故意塞一个未知控件 ⇒ 必须报 warn 且 ok 仍为 true # L8 子表字段的 tableName 陷阱:子表 8 个字段自身的 tableName 全部不是子表名 # -# L6 / L7 是「尺子自己会不会骗人」的证明 —— 没有它们, +# 建表 DDL 规则(P2-b,用 schema.table.create 的 inline 演练 -- 不碰库): +# L9 类型映射:varchar/int/bigint/decimal/datetime/bool ⇒ PG 类型 + 回写视图类型 + dataLength +# L10 复合主键:PRIMARY KEY (f_id, f_tenant_id) +# L11 逻辑删除列:f_delete_mark(INTEGER) / f_delete_time(timestamp) / f_delete_user_id(varchar) +# L12 系统列视图类型:f_version/f_flow_state/f_delete_mark⇒int;租户/流程/删除人⇒varchar;删除时间⇒datetime +# L13 🔴 反自证:logicalDelete=false ⇒ **不加**删除列(不是无条件加) +# L14 🔴 反自证:inline + dryRun=false ⇒ INLINE_REQUIRES_DRY_RUN(演练不许悄悄落库) +# +# L6 / L7 / L13 / L14 是「尺子自己会不会骗人」的证明 —— 没有它们, # 一把永远返回 ok=true 的尺子和「校验真的работает」看起来一模一样。 # # 用法: bash scripts/lowcode-smoke.sh @@ -63,6 +71,36 @@ bad_widget["fields"].append({ "__vModel__": "F_Room", # 复用已有列,确保只有「未知控件」这一条诊断 }) +# ---- 建表规则专用的设计稿(inline 演练:不碰库、不依赖 seed)---- +# 覆盖 6 种标量类型;系统列刻意**不给**(验证平台会自动补齐)。 +ddl_model = [{ + "table": "t_ddl_rules", "tableName": "建表规则", "typeId": "1", + "fields": [ + {"field": "F_Id", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0}, + {"field": "F_Name", "dataType": "varchar", "dataLength": "100", "allowNull": 1}, + {"field": "F_Num", "dataType": "int", "allowNull": 1}, + {"field": "F_Big", "dataType": "bigint", "allowNull": 1}, + {"field": "F_Amt", "dataType": "decimal", "dataLength": "18,2", "allowNull": 1}, + {"field": "F_Time", "dataType": "datetime", "allowNull": 1}, + {"field": "F_Flag", "dataType": "bool", "allowNull": 1}, + ], +}] + + +def ddl_form(logical_delete): + return {"formRef": "formRef", "formModel": "formData", + "primaryKeyPolicy": 1, "logicalDelete": logical_delete, "fields": []} + + +def create_req(i, frm, dry=None): + args = {"formData": json.dumps(frm, ensure_ascii=False), + "tablesData": json.dumps(ddl_model, ensure_ascii=False)} + if dry is not None: + args["dryRun"] = dry + return {"jsonrpc": "2.0", "id": i, "method": "tools/call", + "params": {"name": "sspf_call", + "arguments": {"tool_id": "schema.table.create", "args": args}}} + reqs = [ {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}, {"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sspf_call", "arguments": { @@ -85,6 +123,10 @@ reqs = [ "tool_id": "form.validate", "args": {"formData": json.dumps(bad_widget, ensure_ascii=False), "tablesData": json.dumps(tables, ensure_ascii=False)}}}}, + # ---- 建表 DDL 规则(P2-b)---- + create_req(8, ddl_form(True)), # logicalDelete=true ⇒ 应有删除列 + create_req(9, ddl_form(False)), # logicalDelete=false ⇒ 不该有删除列 + create_req(10, ddl_form(True), dry=False), # 反自证:inline 不许落库 ] with open(out, "w", encoding="utf-8") as f: for r in reqs: @@ -195,6 +237,111 @@ if "test_details" in script: else: bad("L8 子表 tableName 丢了") +# ============ 建表 DDL 规则(P2-b,inline 演练)============ +def ddl_text(i): + return "\n".join((data(i) or {}).get("ddl") or []) + + +def ddl_cols(i): + out = {} + for line in ddl_text(i).splitlines(): + s = line.strip().rstrip(",") + if not s or s.upper().startswith(("CREATE TABLE", "PRIMARY KEY", ")")): + continue + out[s.split()[0].lower()] = s + return out + + +def view_types(i): + out = {} + for t in (data(i) or {}).get("model") or []: + for f in t.get("fields") or []: + out[f.get("field", "").lower()] = (f.get("dataType"), f.get("dataLength")) + return out + + +c8 = ddl_cols(8) +ddl8 = ddl_text(8) +v8 = view_types(8) + +# L9 类型映射(PG 类型) +want_cols = { + "f_name": "f_name VARCHAR(100)", + "f_num": "f_num INTEGER", + "f_big": "f_big BIGINT", + "f_amt": "f_amt DECIMAL(18, 2)", + "f_flag": "f_flag BOOLEAN", +} +missing = [f"{k}→{v}" for k, v in want_cols.items() if c8.get(k) != v] +if not missing and c8.get("f_time", "").startswith("f_time TIMESTAMP(0)"): + ok("L9 类型映射正确(varchar→VARCHAR(100) / int / bigint / decimal(18,2) / datetime / bool)") +else: + bad(f"L9 类型映射不对:{missing};f_time={c8.get('f_time')}") + +# L9b 回写模型的视图类型 + dataLength(只有 varchar/decimal 带长度) +want_view = { + "f_name": ("varchar", "100"), + "f_num": ("int", None), + "f_big": ("bigint", None), + "f_amt": ("decimal", "18,2"), + "f_time": ("datetime", None), + "f_flag": ("bool", None), +} +wrong = {k: v8.get(k) for k, v in want_view.items() if v8.get(k) != v} +if not wrong: + ok("L9b 回写模型视图类型/dataLength 正确(int/bigint/datetime/bool 的长度为 null)") +else: + bad(f"L9b 回写视图类型不对:{wrong}") + +# L10 复合主键 +if "PRIMARY KEY (f_id, f_tenant_id)" in ddl8: + ok("L10 复合主键 (f_id, f_tenant_id) —— 与官方 DDL 一致(单租户也不省这一列)") +else: + bad(f"L10 复合主键不对:{ [l for l in ddl8.splitlines() if 'PRIMARY KEY' in l] }") + +# L11 逻辑删除三列 +del_cols_ok = ( + c8.get("f_delete_mark") == "f_delete_mark INTEGER" + and c8.get("f_delete_time", "").startswith("f_delete_time TIMESTAMP") + and c8.get("f_delete_user_id") == "f_delete_user_id VARCHAR(50)" +) +if del_cols_ok: + ok("L11 逻辑删除列齐备(f_delete_mark INTEGER / f_delete_time / f_delete_user_id)") +else: + bad(f"L11 删除列不对:{ {k: c8.get(k) for k in ('f_delete_mark','f_delete_time','f_delete_user_id')} }") + +# L12 系统列视图类型(官方 DtViewConst 口径) +want_sys = { + "f_version": "int", + "f_flow_state": "int", + "f_delete_mark": "int", + "f_tenant_id": "varchar", + "f_flow_id": "varchar", + "f_flow_task_id": "varchar", + "f_delete_user_id": "varchar", + "f_delete_time": "datetime", +} +bad_sys = {k: v8.get(k) for k, v in want_sys.items() + if (v8.get(k) or (None, None))[0] != v} +if not bad_sys: + ok(f"L12 系统列视图类型正确({len(want_sys)} 列:int×3 / varchar×4 / datetime×1)") +else: + bad(f"L12 系统列视图类型不对:{bad_sys}") + +# L13 🔴 反自证:logicalDelete=false ⇒ 不追加删除列 +leaked = [k for k in ddl_cols(9) if k.startswith("f_delete_")] +if not leaked: + ok("L13 反自证:logicalDelete=false ⇒ 不追加删除列(不是无条件加)") +else: + bad(f"L13 没开逻辑删除却建了删除列:{leaked}") + +# L14 🔴 反自证:inline + dryRun=false 必须被拒 +p10 = payload(10) +if p10.get("ok") is False and p10.get("error", {}).get("code") == "INLINE_REQUIRES_DRY_RUN": + ok("L14 反自证:inline + dryRun=false ⇒ INLINE_REQUIRES_DRY_RUN(演练不许悄悄落库)") +else: + bad(f"L14 inline 落库没被拒: {json.dumps(p10, ensure_ascii=False)[:150]}") + print() print(f"PASS={PASS[0]} FAIL={FAIL[0]}") sys.exit(1 if FAIL[0] else 0) diff --git a/scripts/mcp-smoke.sh b/scripts/mcp-smoke.sh index 34bf1a3..b3435f2 100755 --- a/scripts/mcp-smoke.sh +++ b/scripts/mcp-smoke.sh @@ -23,11 +23,36 @@ # M10 sspf_call(dry_run) 不产生副作用且能报缺参 # M11 **stdout 必须是纯 NDJSON**(每一行都能被 JSON 解析) # M12 **stderr 不得混入协议 JSON**(防止重定向写反) +# M46 data.query 不投影口令/密钥列(藏了几列会明说) +# M47 显式要 f_password ⇒ SENSITIVE_COLUMN +# +# ── 阶段 B:P2-b 低代码动态 CRUD 闭环(M32–M45)── +# +# 先 `--seed-lowcode-demo` 造出示例功能(enCode=receivableDemo), +# 再用**同一个** PGLITE_DIR 起 `--mcp`(新进程能重开同一数据目录)。 +# +# M32 sspf_discover(query=data.record) 能搜到 insert / update / delete +# M33 sspf_describe(data.record.insert, pitfalls) 拿到坑清单 +# M34 data.record.insert 不传 dryRun ⇒ **默认 true**,只出 SQL +# M35 M34 之后 data.query 查不到任何行(默认演练真的没落库) +# M36 dryRun=false ⇒ 真落库,返回主键 +# M37 data.query 查得到(单租户 f_tenant_id='0',f_room 值正确) +# M38 子表 2 行挂在外键上(主表 id = f_receivableid) +# M39 data.record.update 子表**差集**:旧行⇒updateMain、新键⇒insertSub、缺席⇒hardDelete +# M40 差集结果落库:保留行被改、新行进来、缺席行没了 +# M41 delete 不传 dryRun ⇒ 默认演练,行还在 +# M42 delete dryRun=false ⇒ 查不到(logicalDelete=false ⇒ 物理删) +# M43 官方 fixture 没声明 unique ⇒ 同值两行**不被误拒**(尺子不骗人) +# M44 schema.table.create(dryRun) ⇒ 两张表 + 复合主键 + 回写模型含系统列 +# M45 schema.table.create(dryRun=false) 对已存在的表⇒ skipped(幂等,不重建) # # 🔴 M11/M12 是在踩过一次坑之后加的:内嵌 PostgreSQL 会往 fd 1 打 # `PostgreSQL stand-alone backend 17.5` / `backend>`,且它的 single-user 后端 # 会占用 fd 0。内核在开库前用 `dup` 把协议通道整个复制出来(`detach_stdio_for_mcp`), # 这两条断言就是钉住那个行为不被改回去。 +# +# 🔴 阶段 B 由 python 驱动(不是静态 NDJSON):主键是服务端生成的 UUID, +# 静态请求没法在下一条里引用它。响应逐条 flush ⇒ 一问一答不会死锁。 set -u @@ -88,6 +113,8 @@ cat > "$REQ" <<'NDJSON' {"jsonrpc":"2.0","id":27,"method":"prompts/list","params":{}} {"jsonrpc":"2.0","id":28,"method":"prompts/get","params":{"name":"new_business_module","arguments":{"module_name":"冒烟","module_code":"smoke"}}} {"jsonrpc":"2.0","id":29,"method":"prompts/get","params":{"name":"diagnose_menu_not_visible","arguments":{}}} +{"jsonrpc":"2.0","id":30,"method":"tools/call","params":{"name":"sspf_call","arguments":{"tool_id":"data.query","args":{"table":"base_user","limit":2}}}} +{"jsonrpc":"2.0","id":31,"method":"tools/call","params":{"name":"sspf_call","arguments":{"tool_id":"data.query","args":{"table":"base_user","columns":["f_password"],"limit":1}}}} NDJSON echo "── MCP 工具层契约尺子(4 元工具 + 分层加载)──" @@ -101,14 +128,26 @@ if [ "$RC" -ne 0 ]; then exit 2 fi -python3 - "$OUT" "$ERR" <<'PY' +python3 - "$OUT" "$ERR" "$REQ" <<'PY' import json, sys -out_path, err_path = sys.argv[1], sys.argv[2] +out_path, err_path, req_path = sys.argv[1], sys.argv[2], sys.argv[3] PASS = FAIL = 0 def ok(m): global PASS; PASS += 1; print(f" ✅ {m}") def bad(m): global FAIL; FAIL += 1; print(f" ❌ {m}") +# 🔴 期望回复数 **从请求文件算**,不写死 —— 加一条请求不该逼人改断言 +expected = 0 +for line in open(req_path, encoding='utf-8'): + line = line.strip() + if not line: + continue + try: + if "id" in json.loads(line): + expected += 1 + except Exception: + pass + raw = open(out_path, encoding='utf-8', errors='replace').read() lines = [l for l in raw.splitlines() if l.strip()] @@ -165,10 +204,10 @@ else: ok("M3 业务工具不在 tools/list(只能经 discover 访问)") # ---- M4 通知不回复 ---- -if len(parsed) == 29: - ok("M4 29 条带 id 的请求各一个回复;通知无回复") +if len(parsed) == expected: + ok(f"M4 {expected} 条带 id 的请求各一个回复;通知无回复") else: - bad(f"M4 回复数 {len(parsed)},期望 29(通知不该有回复)") + bad(f"M4 回复数 {len(parsed)},期望 {expected}(通知不该有回复)") # ---- M5 context ---- sc = (result(3) or {}).get("structuredContent", {}) @@ -357,16 +396,309 @@ if pm.get("error", {}).get("code") == -32602: else: bad(f"M31 缺参未被拦: {json.dumps(pm, ensure_ascii=False)[:140]}") +# ---- M46/M47 敏感列:通用读工具不许投影口令 ---- +q30 = payload(30) +keys30 = set() +for row in q30.get("rows") or []: + keys30 |= set(row.keys()) +if q30.get("rows") and "password" not in keys30 and "secretkey" not in keys30 \ + and q30.get("hiddenColumns", 0) >= 1: + ok(f"M46 data.query(base_user) 不投影口令列(藏了 {q30['hiddenColumns']} 列)") +else: + bad(f"M46 通用读工具泄漏了口令列: hidden={q30.get('hiddenColumns')} keys={sorted(keys30)[:8]}") + +c31 = (result(31) or {}).get("structuredContent", {}) +if c31.get("ok") is False and c31.get("error", {}).get("code") == "SENSITIVE_COLUMN": + ok("M47 显式要 f_password ⇒ SENSITIVE_COLUMN(不静默少给、也不给哈希)") +else: + bad(f"M47 显式要口令列没被拒: {json.dumps(c31, ensure_ascii=False)[:150]}") + print() print(f"PASS={PASS} FAIL={FAIL}") sys.exit(0 if FAIL == 0 else 1) PY -RC=$? +RC_A=$? + +# ============================================================================ +# 阶段 B:P2-b 低代码动态 CRUD(种子 → 写工具 → 查证 → 删) +# ============================================================================ + +echo +echo "── 阶段 B:低代码动态 CRUD(receivableDemo)──" + +if PGLITE_DIR="$TMP/db" "$BIN" --seed-lowcode-demo > "$TMP/seed.log" 2>&1; then + if grep -q "receivableDemo" "$TMP/seed.log"; then + echo " ✅ 种子:receivableDemo 已就绪(建表 + 回写模型)" + else + echo " ❌ 种子跑完了但没报出 enCode=receivableDemo" + tail -6 "$TMP/seed.log" | sed 's/^/ /' + fi +else + echo " ❌ 种子失败(--seed-lowcode-demo)" + grep -vE "stand-alone|^backend>" "$TMP/seed.log" | tail -8 | sed 's/^/ /' + RC_A=1 +fi + +python3 - "$BIN" "$TMP/db" "$TMP" <<'PY' +import json, os, subprocess, sys, traceback + +BIN, DBDIR, TMP = sys.argv[1], sys.argv[2], sys.argv[3] +env = dict(os.environ) +env["PGLITE_DIR"] = DBDIR +err = open(os.path.join(TMP, "mcp-b.stderr"), "w", encoding="utf-8") +proc = subprocess.Popen( + [BIN, "--mcp"], + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=err, + env=env, text=True, bufsize=1, encoding="utf-8", +) + +PASS = FAIL = 0 +def ok(m): + global PASS; PASS += 1; print(f" ✅ {m}") +def bad(m): + global FAIL; FAIL += 1; print(f" ❌ {m}") + +_next = [0] +def send(method, params): + _next[0] += 1 + rid = _next[0] + proc.stdin.write(json.dumps( + {"jsonrpc": "2.0", "id": rid, "method": method, "params": params}, + ensure_ascii=False) + "\n") + proc.stdin.flush() + while True: + line = proc.stdout.readline() + if not line: + raise RuntimeError(f"进程在读 {method}#{rid} 时退出(见 {TMP}/mcp-b.stderr)") + line = line.strip() + if not line: + continue + try: + msg = json.loads(line) + except Exception: + continue + if msg.get("id") == rid: + return msg + +def notify(method): + proc.stdin.write(json.dumps({"jsonrpc": "2.0", "method": method}) + "\n") + proc.stdin.flush() + +def invoke(tool, args=None): + msg = send("tools/call", {"name": "sspf_call", + "arguments": {"tool_id": tool, "args": args or {}}}) + return (msg.get("result") or {}).get("structuredContent") or {} + +def meta_call(name, args): + msg = send("tools/call", {"name": name, "arguments": args}) + return (msg.get("result") or {}).get("structuredContent") or {} + +def show(sc, n=160): + return json.dumps(sc, ensure_ascii=False)[:n] + +def kinds(outcome): + return [s.get("kind") for s in (outcome.get("sql") or [])] + +EN = "receivableDemo" +MAIN = {"F_Building": "1号楼", "F_Room": "A-101", "F_Company_name": "冒烟公司", + "F_Userid": "苏苏", "F_Phone": "13800000000", "F_Ost": "经理"} +SUB = {"F_Month": "2026-10", "F_Rent": 1200.5, "F_Water_rent": 10, + "F_Powerrate": 20, "F_Property": 30, "F_Cleaning": 5, + "F_Pollutant": 2, "F_Totalbilling": 1267.5} + +def payload(extra_sub=None): + p = dict(MAIN) + # 两行子表:差集断言需要「一行保留、一行缺席」 + p["tableField107"] = extra_sub if extra_sub is not None else [ + dict(SUB), {**SUB, "F_Month": "2026-11", "F_Rent": 800}, + ] + return p + +try: + send("initialize", {}) + notify("notifications/initialized") + + # ---- M32 discover 能搜到三个写工具 ---- + d = meta_call("sspf_discover", {"query": "data.record"}) + ids = {r.get("id") for r in (d.get("results") or [])} + want = {"data.record.insert", "data.record.update", "data.record.delete"} + if want <= ids: + ok(f"M32 discover(query=data.record) 找到 3 个写工具(共 {d.get('count')} 条结果)") + else: + bad(f"M32 discover 少了工具:缺 {sorted(want - ids)}(实际 {sorted(ids)})") + + # ---- M33 describe 拿到坑 ---- + d = meta_call("sspf_describe", {"tool_id": "data.record.insert", "level": "pitfalls"}) + if d.get("ok") and len(d.get("pitfalls") or []) >= 3: + ok(f"M33 describe(data.record.insert) 返回 {len(d['pitfalls'])} 个坑") + else: + bad(f"M33 describe 异常: {show(d)}") + + # ---- M34 不传 dryRun ⇒ 默认演练 ---- + sc = invoke("data.record.insert", {"enCode": EN, "data": payload()}) + ins = sc.get("data") or {} + if sc.get("ok") is True and ins.get("dryRun") is True and ins.get("statements", 0) >= 2: + ok(f"M34 insert 不传 dryRun ⇒ 默认演练({ins['statements']} 条 SQL,没落库)") + else: + bad(f"M34 默认 dryRun 失效: {show(sc)}") + + # ---- M35 演练真的没写 ---- + q = invoke("data.query", {"table": "test_receivable", "columns": ["f_id"], "limit": 10}) + if (q.get("data") or {}).get("count") == 0: + ok("M35 演练后表里 0 行(默认 dryRun 没有副作用)") + else: + bad(f"M35 演练却落库了: {show(q)}") + + # ---- M36 真落库 ---- + sc = invoke("data.record.insert", {"enCode": EN, "data": payload(), "dryRun": False}) + ins = sc.get("data") or {} + rid = ins.get("id") or "" + if sc.get("ok") is True and ins.get("dryRun") is False and rid: + ok(f"M36 insert(dryRun=false) 落库成功(id={rid[:8]}…,{ins['statements']} 条 SQL)") + else: + bad(f"M36 落库失败: {show(sc)}") + raise SystemExit(0) + + # ---- M37 查得到(单租户 f_tenant_id='0')---- + q = invoke("data.query", {"table": "test_receivable", "limit": 10, + "where": [{"column": "f_id", "op": "eq", "value": rid}]}) + rows = (q.get("data") or {}).get("rows") or [] + row = rows[0] if rows else {} + if len(rows) == 1 and row.get("room") == "A-101" and str(row.get("tenantId")) == "0": + ok("M37 data.query 查得到(room=A-101,tenantId=0 —— 单租户口径)") + else: + bad(f"M37 查不到或租户不对: {show(q)}") + + # ---- M38 子表挂在外键上 ---- + def subs_of(main_id): + q = invoke("data.query", {"table": "test_details", "limit": 50, + "columns": ["f_id", "f_receivableid", "f_month", "f_rent"], + "where": [{"column": "f_receivableid", "op": "eq", + "value": main_id}]}) + return (q.get("data") or {}).get("rows") or [] + + subs = subs_of(rid) + if len(subs) == 2 and all(str(s.get("receivableid")) == rid for s in subs): + ok(f"M38 子表 2 行挂在外键上(f_receivableid={rid[:8]}…)") + else: + bad(f"M38 子表行数/外键不对: {show(subs)}") + raise SystemExit(0) + + keep, drop = subs[0].get("id"), subs[1].get("id") + new_key = "smoke-sub-new" + + # ---- M39 子表差集:保留⇒update、新键⇒insert、缺席⇒delete ---- + sc = invoke("data.record.update", { + "enCode": EN, "recordId": rid, "dryRun": False, + "data": {"F_Room": "A-102", "tableField107": [ + {"F_Id": keep, "F_Month": "2026-11", "F_Rent": 1300.5}, + {"F_Id": new_key, "F_Month": "2026-12", "F_Rent": 1}, + ]}, + }) + up = sc.get("data") or {} + ks = kinds(up) + if (sc.get("ok") is True and "updateMain" in ks + and "updateSub" in ks and "insertSub" in ks and "hardDelete" in ks): + ok(f"M39 update 子表差集三类都生成({', '.join(ks)})") + else: + bad(f"M39 差集不对: kinds={ks} {show(sc)}") + + # ---- M40 差集结果落库 ---- + subs2 = subs_of(rid) + got = {s.get("id") for s in subs2} + kept = next((s for s in subs2 if s.get("id") == keep), {}) + q = invoke("data.query", {"table": "test_receivable", "limit": 5, + "columns": ["f_room"], + "where": [{"column": "f_id", "op": "eq", "value": rid}]}) + room = ((q.get("data") or {}).get("rows") or [{}])[0].get("room") + if (got == {keep, new_key} and drop not in got + and str(kept.get("rent")) in ("1300.5", "1300.50") + and room == "A-102"): + ok("M40 差集落库正确:保留行改了、新行进来、缺席行没了;主表也改了") + else: + bad(f"M40 差集结果不对: ids={sorted(x for x in got if x)} rent={kept.get('rent')} room={room}") + + # ---- M41 delete 默认演练 ---- + sc = invoke("data.record.delete", {"enCode": EN, "recordId": rid}) + still = invoke("data.query", {"table": "test_receivable", "limit": 5, + "columns": ["f_id"], + "where": [{"column": "f_id", "op": "eq", "value": rid}]}) + if (sc.get("ok") is True and (sc.get("data") or {}).get("dryRun") is True + and (still.get("data") or {}).get("count") == 1): + ok("M41 delete 不传 dryRun ⇒ 默认演练,行还在") + else: + bad(f"M41 delete 默认值失效: {show(sc)}") + + # ---- M42 真删 ---- + sc = invoke("data.record.delete", {"enCode": EN, "recordId": rid, "dryRun": False}) + gone = invoke("data.query", {"table": "test_receivable", "limit": 5, + "columns": ["f_id"], + "where": [{"column": "f_id", "op": "eq", "value": rid}]}) + n_sub = len(subs_of(rid)) + if (sc.get("ok") is True and (gone.get("data") or {}).get("count") == 0 + and n_sub == 0): + ok("M42 delete(dryRun=false) ⇒ 主表查不到、子表也没了(logicalDelete=false ⇒ 物理删)") + else: + bad(f"M42 删除不彻底: main={show(gone)} subs={n_sub}") + + # ---- M43 官方 fixture 没声明 unique ⇒ 同值不误拒 ---- + a = invoke("data.record.insert", {"enCode": EN, "data": payload([]), "dryRun": False}) + b = invoke("data.record.insert", {"enCode": EN, "data": payload([]), "dryRun": False}) + if a.get("ok") is True and b.get("ok") is True: + ok("M43 官方 fixture 无 unique 控件 ⇒ 同值两行不被误拒(校验不越界)") + else: + bad(f"M43 误拒了重复值: {show(a)} / {show(b)}") + + # ---- M44 建表工具:dry-run 出 DDL ---- + sc = invoke("schema.table.create", {"enCode": EN}) + d = sc.get("data") or {} + ddl = "\n".join(d.get("ddl") or []) + model = d.get("model") or [] + tenant = [f for t in model for f in t.get("fields") or [] if f.get("field") == "f_tenant_id"] + if (sc.get("ok") is True and d.get("dryRun") is True and len(d.get("tables") or []) == 2 + and "PRIMARY KEY (f_id, f_tenant_id)" in ddl + and tenant and tenant[0].get("dataType") == "varchar"): + ok("M44 schema.table.create(dryRun) ⇒ 2 张表 + 复合主键 + 回写模型含系统列") + else: + bad(f"M44 建表演练异常: {show(sc, 200)}") + + # ---- M45 幂等:表已存在 ⇒ skipped ---- + sc = invoke("schema.table.create", {"enCode": EN, "dryRun": False}) + d = sc.get("data") or {} + if (sc.get("ok") is True and not (d.get("tables") or []) + and len(d.get("skipped") or []) == 2): + ok("M45 对已存在的表再建 ⇒ skipped 两张(幂等,不重建)") + else: + bad(f"M45 幂等失效: {show(sc, 200)}") + +except SystemExit: + pass +except Exception: + bad("阶段 B 异常中断") + traceback.print_exc() +finally: + try: + proc.stdin.close() + except Exception: + pass + try: + proc.wait(timeout=30) + except Exception: + proc.kill() + err.close() + +print() +print(f"PASS={PASS} FAIL={FAIL}") +sys.exit(0 if FAIL == 0 else 1) +PY + +RC_B=$? echo "--------------------" -if [ "$RC" -eq 0 ]; then - echo "全绿 ✅(MCP 工具层契约闭环)" +if [ "$RC_A" -eq 0 ] && [ "$RC_B" -eq 0 ]; then + echo "全绿 ✅(MCP 工具层契约闭环 + 低代码动态 CRUD)" else echo "有 ❌,按上面修" fi -exit "$RC" +[ "$RC_A" -ne 0 ] && exit "$RC_A" +exit "$RC_B" diff --git a/src/backend/src/mcp_adapter.rs b/src/backend/src/mcp_adapter.rs index 73f69db..5a6ac15 100644 --- a/src/backend/src/mcp_adapter.rs +++ b/src/backend/src/mcp_adapter.rs @@ -383,14 +383,25 @@ impl NativeAdapter { .field("table") .next("schema.table.list", json!({}), "确认表名")); } - let allowed: HashSet = cols.iter().cloned().collect(); - // 选列:缺省全选;显式给了就逐个校验 + // 🔴 口令/密钥列**不许经通用读口子投影**(红线⑤)。 + // `data.query` 是「按表名读任意表」的通用口子:不挡这里, + // 一句 `{"table":"base_user"}` 就能把全库口令哈希拖走(实测会返回 password)。 + let readable: Vec = cols + .iter() + .filter(|c| !is_sensitive_column(c)) + .cloned() + .collect(); + let allowed: HashSet = readable.iter().cloned().collect(); + let n_hidden = cols.len() - readable.len(); + + // 选列:缺省全选(已滤掉敏感列);显式给了就逐个校验 let select = match args.get("columns").and_then(Value::as_array) { Some(arr) if !arr.is_empty() => { let mut v = Vec::with_capacity(arr.len()); for c in arr { let name = c.as_str().unwrap_or(""); + ensure_not_sensitive(name, "columns")?; if !allowed.contains(name) { return Err(ToolError::new( "UNKNOWN_COLUMN", @@ -403,7 +414,7 @@ impl NativeAdapter { } v.join(", ") } - _ => cols + _ => readable .iter() .map(|c| format!("\"{c}\"")) .collect::>() @@ -416,12 +427,17 @@ impl NativeAdapter { .and_then(Value::as_array) .cloned() .unwrap_or_default(); + for c in &conds { + let col = c.get("column").and_then(Value::as_str).unwrap_or(""); + ensure_not_sensitive(col, "where.column")?; + } let mut params: Vec = Vec::new(); let where_sql = Self::build_where(&conds, &allowed, &mut params)?; // 排序(列名同样走白名单) let order_sql = match args.get("orderBy").and_then(Value::as_str) { Some(ob) if !ob.is_empty() => { + ensure_not_sensitive(ob, "orderBy")?; if !allowed.contains(ob) { return Err(ToolError::new("UNKNOWN_COLUMN", format!("排序列不存在: {ob}")) .field("orderBy")); @@ -454,6 +470,8 @@ impl NativeAdapter { "table": table, "count": rows.len(), "limit": limit, + // 🔴 明说「藏着几列」—— 否则 AI 会以为这张表就这么多列 + "hiddenColumns": n_hidden, "rows": rows, })) } @@ -476,6 +494,10 @@ impl NativeAdapter { .and_then(Value::as_array) .cloned() .unwrap_or_default(); + for c in &conds { + let col = c.get("column").and_then(Value::as_str).unwrap_or(""); + ensure_not_sensitive(col, "where.column")?; + } let mut params: Vec = Vec::new(); let where_sql = Self::build_where(&conds, &allowed, &mut params)?; @@ -1858,9 +1880,26 @@ impl NativeAdapter { args: &Value, ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { let row = self.load_visualdev(args).await?; + Self::lowcode_from_row(&row) + } - let form_text = row["formData"].as_str().unwrap_or("").trim().to_string(); - let tables_text = row["tablesData"].as_str().unwrap_or("").trim().to_string(); + /// 从 `base_visual_dev` 的一行解析出(表单, 模型)。 + fn lowcode_from_row( + row: &Value, + ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { + Self::lowcode_from_json( + row["formData"].as_str().unwrap_or(""), + row["tablesData"].as_str().unwrap_or(""), + ) + } + + /// 🔴 解析设计稿(`f_form_data` + `f_tables_data`)—— 库内行与内联入参共用。 + fn lowcode_from_json( + form_text: &str, + tables_text: &str, + ) -> Result<(sspf_lowcode::FormSchema, sspf_lowcode::ModelSchema), ToolError> { + let form_text = form_text.trim(); + let tables_text = tables_text.trim(); if form_text.is_empty() || tables_text.is_empty() { return Err(ToolError::new( @@ -1870,15 +1909,14 @@ impl NativeAdapter { .hint("只有表单没模型 = 不知道该存哪张表;只有模型没表单 = 不知道该展示什么")); } - let fv: Value = serde_json::from_str(&form_text) + 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) + 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 model = sspf_lowcode::ModelSchema::parse(&tv) + .map_err(|e| ToolError::new(e.code(), e.message()).field("tablesData"))?; Ok((form, model)) } @@ -1923,6 +1961,103 @@ impl NativeAdapter { }) } + /// `schema.table.create` —— 按设计稿建物理表,并回写 `f_tables_data`。 + /// + /// 两种模式: + /// + /// | 模式 | 入参 | 能落库吗 | + /// |---|---|---| + /// | 库内功能 | `id` / `enCode` | ✅(`dryRun=false` 时建表 + 回写) | + /// | 内联设计稿 | `formData` + `tablesData` | ❌ 只能演练(没有回写目标) | + /// + /// 🔴 内联模式的意义:设计稿还没入库时就能看到 DDL —— + /// 与 `form.validate` 的 inline 模式同款,也方便冒烟脚本钉住建表规则。 + async fn schema_table_create(&self, args: &Value) -> Result { + let dry_run = Self::dry_run_flag(args); + + let inline_form = args + .get("formData") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + let inline_tables = args + .get("tablesData") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + + // ---- 内联设计稿:只能演练 ---- + if !inline_form.is_empty() || !inline_tables.is_empty() { + if inline_form.is_empty() || inline_tables.is_empty() { + let missing = if inline_form.is_empty() { + "formData" + } else { + "tablesData" + }; + return Err(ToolError::new( + "MISSING_ARG", + "内联模式要同时给 formData 与 tablesData", + ) + .field(missing) + .hint( + "表单决定 logicalDelete / 主键策略,模型决定列 —— \ + 只给一半就建不出正确的表", + )); + } + if !dry_run { + return Err(ToolError::new( + "INLINE_REQUIRES_DRY_RUN", + "内联设计稿只能演练,不能落库", + ) + .field("dryRun") + .hint( + "落库要绑定一条功能记录(回写的目标)—— \ + 先把设计稿存进 base_visual_dev,再用 id / enCode 调", + )); + } + + let (form, model) = Self::lowcode_from_json(&inline_form, &inline_tables)?; + let outcome = + crate::lowcode_ddl::create_tables(&self.state.db, &model, &form, true).await?; + return Ok(Self::ddl_json(None, &outcome)); + } + + // ---- 库内功能:建表 + 回写 ---- + let row = self.load_visualdev(args).await?; + let (form, model) = Self::lowcode_from_row(&row)?; + let visualdev_id = row["id"].as_str().unwrap_or("").to_string(); + + let outcome = crate::lowcode_ddl::create_and_sync( + &self.state.db, + &visualdev_id, + &model, + &form, + dry_run, + ) + .await?; + + Ok(Self::ddl_json(Some(&visualdev_id), &outcome)) + } + + /// 把建表结果整理成工具输出。 + fn ddl_json( + visualdev_id: Option<&str>, + outcome: &crate::lowcode_ddl::CreateTablesOutcome, + ) -> Value { + json!({ + "id": visualdev_id, + "dryRun": outcome.dry_run, + "tables": outcome.tables, + "skipped": outcome.skipped, + "statements": outcome.ddl.len(), + "ddl": outcome.ddl, + "model": outcome.model, + "notes": outcome.notes, + }) + } + /// `data.record.insert` —— 按设计稿新增一条记录(主表 + 子表)。 async fn data_record_insert(&self, args: &Value) -> Result { let (form, model) = self.load_lowcode(args).await?; @@ -2032,6 +2167,43 @@ impl NativeAdapter { } } +/// 🔴 **不许经通用读工具投影/过滤的列**(口令与密钥)。 +/// +/// ## 为什么需要这一层 +/// +/// `data.query` / `data.count` 是「按表名读任意表」的通用口子。 +/// 不在这里挡,一句 `{"table":"base_user"}` 就能把全库口令哈希拖走 +/// (实测修复前确实返回了 `password` / `secretkey` 两列)。 +/// +/// ⇒ 三条约束: +/// 1. 缺省投影**滤掉**这些列; +/// 2. 显式 `columns` 要这些列 ⇒ `SENSITIVE_COLUMN`(不静默少给); +/// 3. `where` / `orderBy` 用它们 ⇒ 同样拒绝(否则成了「按哈希猜明文」的 oracle)。 +const SENSITIVE_COLUMNS: &[&str] = &["f_password", "f_secretkey"]; + +/// 是否敏感列(大小写不敏感 —— PG 会把标识符折叠成小写)。 +fn is_sensitive_column(name: &str) -> bool { + SENSITIVE_COLUMNS.iter().any(|c| c.eq_ignore_ascii_case(name)) +} + +/// 🔴 敏感列一律拒绝,并说清「为什么 + 去哪拿」。 +fn ensure_not_sensitive(name: &str, field: &'static str) -> Result<(), ToolError> { + if !is_sensitive_column(name) { + return Ok(()); + } + Err(ToolError::new( + "SENSITIVE_COLUMN", + format!("列 {name} 属于口令/密钥,不允许经通用读工具访问"), + ) + .field(field.to_string()) + .hint("口令列只存在于 base_user,任何工具都不投影它") + .next( + "permission.user.list", + json!({}), + "要看用户信息用这个(它本来就不返回口令字段)", + )) +} + /// `form_err` —— 把 lowcode 的解析错误转成结构化工具错误。 fn form_err(e: sspf_lowcode::FormError) -> ToolError { ToolError::new(e.code(), e.message()) @@ -2361,6 +2533,7 @@ impl PlatformAdapter for NativeAdapter { "form.validate" => self.form_validate(&args).await, // ------------------------------------------------ 低代码动态 CRUD(P2-b,写) + "schema.table.create" => self.schema_table_create(&args).await, "data.record.insert" => self.data_record_insert(&args).await, "data.record.update" => self.data_record_update(&args).await, "data.record.delete" => self.data_record_delete(&args).await, @@ -2394,6 +2567,19 @@ mod tests { assert!(valid_table("").is_none()); } + /// 🔴 口令/密钥列必须在通用读工具入口就被挡住。 + #[test] + fn sensitive_columns_are_blocked() { + assert!(is_sensitive_column("f_password")); + assert!(is_sensitive_column("F_PASSWORD"), "PG 折叠大小写,判断要不敏感"); + assert!(is_sensitive_column("f_secretkey")); + assert!(!is_sensitive_column("f_account")); + let e = ensure_not_sensitive("f_password", "columns").unwrap_err(); + assert_eq!(e.code, "SENSITIVE_COLUMN"); + assert!(!e.hints.is_empty(), "拒绝时要说清去哪拿用户信息"); + assert!(ensure_not_sensitive("f_account", "columns").is_ok()); + } + /// 错误对象必须带 next_actions(AI 自纠的依据)。 #[test] fn db_error_carries_hint_and_is_retryable() {