@stalfh233/omc-cli 0.6.7 → 0.6.10

package/dist/lanes/datarule.js

@@ -13,6 +13,7 @@ import { runtimeWriteWithAppMapping } from "../runtime-support.js";
 import { DATARULE_LANE_CONTRACT, DATARULE_TYPE_OPTION_KEYS } from "./datarule-contract.js";
 import { normalizeAggregationFormula } from "../field-families.js";
 import { CONDITION_PROTOCOL_EXAMPLES, dataRuleOptionsShapeError } from "./datarule-protocol.js";
+import { readModelRecord } from "../model-record.js";
 const DATARULE_LANE = DATARULE_LANE_CONTRACT.lane;
 const DATARULE_TOOLS = DATARULE_LANE_CONTRACT.tools;
 const dataRuleTypeArg = z
@@ -20,7 +21,13 @@ const dataRuleTypeArg = z
     .int()
     .min(1)
     .max(5)
-    .describe("field-level rule type: 1 校验 / 2 计算拼接 / 3 显示 / 4 必填 / 5 只读 (8 EXTENSION is out of scope)");
+    .describe("field-level rule type → options 键映射：" +
+    "1 校验 → options.conditions/prompt/regexp/maxLength…（配合 checkType 1/2/3/4/5）；" +
+    "2 计算拼接 → options.shortTextStitch|expression（须为含 formula 的 JSON 对象字符串）；" +
+    "3 显示 → options.displayFormula；" +
+    "4 必填 → options.requiredFormula（无条件必填用字面量 \"true\"；条件式如 \"{amount} 大于 {\\\"valueType\\\":\\\"custom\\\",\\\"value\\\":0}\"）；" +
+    "5 只读 → options.readonlyCondition。" +
+    "8 EXTENSION 不在范围。表单运行时条件优先 field.update（见 datarule.create summary）。");
 const dataRuleOptionsArg = z
     .record(z.unknown())
     .describe("rule options object, sent to the wire as a JSON string; type4 requires requiredFormula, type5 readonlyCondition, type3 displayFormula, type2 shortTextStitch|expression, type1 a check key keyed by checkType");
@@ -741,166 +748,243 @@ export function registerDataRuleLane(tools) {
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // r28g F32：与 rule.list 同口径——模型不存在时 ok + modelPresent:false，
+            // 不把平台 601003 原样 refused（三种读面反应不一致）。
+            const modelRecord = await readModelRecord(session, args.schemaCode);
+            if (modelRecord === null) {
+                return {
+                    schemaCode: args.schemaCode,
+                    dataRuleType: args.dataRuleType ?? null,
+                    modelPresent: false,
+                    rules: [],
+                    rulesCount: 0,
+                    hint: "模型不存在（bizmodels/get_all 空）——空规则不是「已清干净的证据」也不是错误；判定模型面用 model.inspect",
+                };
+            }
             const rows = await listDataRules(session, args.schemaCode, args.dataRuleType);
             return {
                 schemaCode: args.schemaCode,
                 dataRuleType: args.dataRuleType ?? null,
+                modelPresent: true,
+                rulesCount: rows.length,
                 rules: rows.map(decodeDataRule),
             };
+        }, {
+            target: `datarule.list:${args.schemaCode}:${args.dataRuleType ?? "*"}`,
+            // r28g F12：默认 compact 把 BULKY `rules` 折成 rulesCount + rules:[]，
+            // 6 条带 options 就触发「数据丢失假象」。自定义 compact 保形为库存摘要
+            // （id/type/property/checkType/name + optionsKeys），完整 options 仍在
+            // detailArtifactId。
+            compact: (result) => {
+                const rules = Array.isArray(result.rules) ? result.rules : [];
+                const inventory = rules.map((row) => {
+                    const options = row.options && typeof row.options === "object" && !Array.isArray(row.options)
+                        ? row.options
+                        : null;
+                    return {
+                        id: row.id ?? null,
+                        propertyCode: row.propertyCode ?? null,
+                        propertyCodes: row.propertyCodes ?? [],
+                        dataRuleType: row.dataRuleType ?? null,
+                        checkType: row.checkType ?? null,
+                        name: row.name ?? null,
+                        ...(options ? { optionsKeys: Object.keys(options) } : {}),
+                        ...(typeof row.shapeWarning === "string" ? { shapeWarning: row.shapeWarning } : {}),
+                    };
+                });
+                return {
+                    schemaCode: result.schemaCode,
+                    dataRuleType: result.dataRuleType ?? null,
+                    modelPresent: result.modelPresent,
+                    rulesCount: typeof result.rulesCount === "number" ? result.rulesCount : inventory.length,
+                    rules: inventory,
+                    rulesOmitted: true,
+                    rulesOmittedNote: "内联 rules 是库存摘要（无 options 正文）；完整行在 detailArtifactId——`omc artifact get <id> --jq 'rules'` 或本次 call 加 `--jq rules` / `--extract rules`。",
+                    ...(typeof result.hint === "string" ? { hint: result.hint } : {}),
+                };
+            },
         }),
     }));
-    writeTool(tools, "datarule.create", DATARULE_LANE, DATARULE_TOOLS["datarule.create"].scope, DATARULE_TOOLS["datarule.create"].description, {
-        schemaCode: z.string().min(1),
-        propertyCode: propertyCodeArg,
-        propertyCodes: propertyCodesArg,
-        dataRuleType: dataRuleTypeArg,
-        options: dataRuleOptionsArg,
-        checkType: checkTypeArg,
-        childRule: z.boolean().optional(),
-        name: z.string().optional(),
-        sortKey: z.number().int().optional(),
-    }, async (session, args) => {
-        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
-        assertDataRuleCheckType(args.dataRuleType, args.checkType);
-        assertDataRuleTarget(args);
-        const codes = dataRuleTargetCodes(args);
-        const published = await readPublishedFieldCodesOrNull(session, args.schemaCode);
-        await assertChildFormulaRefs(session, args, published);
-        if (published !== null) {
-            const missing = codes.filter((code) => !published.has(code));
-            if (missing.length > 0)
-                throw new ToolRefusalError({ status: "refused", blocker: "datarule-property-not-published", schemaCode: args.schemaCode, propertyCodes: codes, missing, message: `字段 ${args.schemaCode}.${missing.join(",")} 不在发布面上；拒绝 datarule.create POST` });
-        }
-        const existingRules = await listDataRules(session, args.schemaCode);
-        // dataRuleType 1 (CHECK_RULE) fans out into 5 checkTypes that COEXIST on one
-        // field (the platform auto-creates a checkType 4 maxLength row per text
-        // field), so the clash key there is field + `checkType`, not field + type.
-        if (existingRules.some((row) => {
-            if (Number(row.dataRuleType) !== args.dataRuleType)
-                return false;
-            if (!storedTargetCodes(row).some((code) => codes.includes(code)))
-                return false;
-            return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
-        }))
-            throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", schemaCode: args.schemaCode, propertyCodes: codes, dataRuleType: args.dataRuleType, ...(args.dataRuleType === 1 ? { checkType: args.checkType } : {}), message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝重复 POST` });
-        const createRule = () => wireCall(session, {
-            path: ENDPOINTS.dataRuleCreate,
-            method: "POST",
-            body: dataRuleBody(args, JSON.stringify(withOptionsPropertyCodes(withStitchEditorText(args.options), codes))),
-        });
-        // Ticket 78: ONLY type2 CALCULATE has the corroborated unpublished-app
-        // FALSE dead-cycle 305003 (checkCalculateRulesDeadCycle mis-concatenates
-        // schemaCode.propertyCode when getAppFunctionByCode is null); types
-        // 3/4/5 keep the plain wire failure.
-        const performed = args.dataRuleType === 2
-            ? await runtimeWriteWithAppMapping(session, args.schemaCode, 305003, "datarule.create 类型2 CALCULATE 报死循环（305003，误判）", createRule)
-            : await createRule();
-        const rules = (await listDataRules(session, args.schemaCode, args.dataRuleType)).filter((row) => storedTargetCodes(row).some((code) => codes.includes(code)));
-        return {
-            performed: { errcode: performed.errcode },
-            readback: {
-                schemaCode: args.schemaCode,
-                propertyCodes: codes,
-                dataRuleType: args.dataRuleType,
-                matchedCount: rules.length,
-                rules: rules.map(decodeDataRule),
-                ...(args.dataRuleType >= 3 ? { advisory: DATARULE_FORM_INTERACTION_ADVISORY } : {}),
-                // r35（2026-10-31 真机）：type1 校验规则建好读回一致，但 REST `data.submit`
-                // 提交违规数据（-50 / 超阈值）errcode 0 放行、原值落库——校验在门户前端
-                // 提交管线执行，REST 不拦。先告知执行面，省掉「先实测两轮才发现不生效」。
-                ...(args.dataRuleType === 1
-                    ? { executionWarning: "校验规则在门户前端提交时执行；REST `data.submit` 不拦截违规数据（r35 真机：-50 与超阈值均 errcode 0 放行）。验收拦截效果需走门户，或改用业务规则（BIZ_ACTION/条件）在服务端拦。" }
-                    : {}),
-                ...(() => { const w = dataRuleFormulaWarnings(args.dataRuleType, args.options); return w.length ? { lintWarnings: w } : {}; })(),
-            },
-        };
-    }, 
-    // T-04: the type-2 shape gate is static — refuse BEFORE the write permission gate.
-    (args) => {
-        assertDataRuleTarget(args);
-        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
-        assertDataRuleCheckType(args.dataRuleType, args.checkType);
-    }, 
-    // Dry-run is the cheapest place to see the formula lint (the platform
-    // validates nothing at create time; the failure surfaces at submit).
-    async (_session, args) => {
-        const lintWarnings = dataRuleFormulaWarnings(args.dataRuleType, args.options);
-        return lintWarnings.length ? { lintWarnings } : {};
-    }, dataruleRollbackSpec("datarule.create"));
-    writeTool(tools, "datarule.update", DATARULE_LANE, DATARULE_TOOLS["datarule.update"].scope, DATARULE_TOOLS["datarule.update"].description, {
-        id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
-        schemaCode: z.string().min(1),
-        propertyCode: propertyCodeArg,
-        propertyCodes: propertyCodesArg,
-        dataRuleType: dataRuleTypeArg,
-        options: dataRuleOptionsArg,
-        checkType: checkTypeArg,
-        childRule: z.boolean().optional(),
-        name: z.string().optional(),
-        sortKey: z.number().int().optional(),
-    }, async (session, args) => {
-        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
-        assertDataRuleCheckType(args.dataRuleType, args.checkType);
-        const id = await locateDataRuleId(session, args, "update POST");
-        const before = await listDataRules(session, args.schemaCode);
-        const current = before.find((row) => row.id === id);
-        if (!current)
-            throw new ToolRefusalError({ status: "refused", blocker: "datarule-absent", message: `数据规则 ${id} 不存在于 ${args.schemaCode}；拒绝 update POST` });
-        // The stored childRule governs when the caller omits it (full-row update).
-        const patchArgs = { ...args, id };
-        await assertChildFormulaRefs(session, { ...patchArgs, childRule: args.childRule ?? current.childRule === true });
-        // Keep the existing binding when the caller omits a target (the platform
-        // update is a full-row overwrite — an empty patch would clear propertyCodes).
-        const requested = dataRuleTargetCodes(patchArgs);
-        const codes = requested.length > 0 ? requested : storedTargetCodes(current);
-        const boundArgs = { ...patchArgs, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes };
-        if (before.some((row) => {
-            if (row.id === id)
-                return false;
-            if (Number(row.dataRuleType) !== args.dataRuleType)
-                return false;
-            if (!storedTargetCodes(row).some((code) => codes.includes(code)))
-                return false;
-            return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
-        }))
-            throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝 update POST` });
-        const beforeDecoded = decodeDataRule(current);
-        const performed = await wireCall(session, {
-            path: ENDPOINTS.dataRuleUpdate,
-            method: "POST",
-            body: fullDataRuleBody(current, boundArgs, JSON.stringify(withOptionsPropertyCodes(withStitchEditorText(args.options), codes))),
-        });
-        const record = (await listDataRules(session, args.schemaCode, args.dataRuleType)).find((row) => row.id === id);
-        if (!record)
-            throw new WireError("business", `data rule ${id} disappeared after update`, 304001);
-        const afterDecoded = decodeDataRule(record);
-        const proof = dataRuleChanges(beforeDecoded, afterDecoded);
-        return {
-            performed: { errcode: performed.errcode },
-            readback: { id, present: true, before: beforeDecoded, after: afterDecoded, changedFields: proof.changedFields, unexpectedChanges: proof.unexpectedChanges, rule: afterDecoded },
-        };
-    }, (args) => {
-        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
-    }, undefined, dataruleRollbackSpec("datarule.update"));
-    writeTool(tools, "datarule.delete", DATARULE_LANE, DATARULE_TOOLS["datarule.delete"].scope, DATARULE_TOOLS["datarule.delete"].description, {
-        id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
-        schemaCode: z.string().min(1),
-        propertyCode: propertyCodeArg,
-        propertyCodes: propertyCodesArg,
-        dataRuleType: z.number().int().min(1).max(5).optional().describe("业务键定位去歧义：同一字段可能有多条规则（如必填+只读），用它指定要删的类型"),
-    }, async (session, args) => {
-        const id = await locateDataRuleId(session, args, "delete POST");
-        const before = (await listDataRules(session, args.schemaCode)).find((row) => row.id === id);
-        const performed = await wireCall(session, {
-            path: ENDPOINTS.dataRuleDelete,
-            method: "POST",
-            query: { id },
-        });
-        const after = await listDataRules(session, args.schemaCode);
-        return {
-            performed: { errcode: performed.errcode },
-            readback: { id, existedBefore: before !== undefined, absent: !after.some((row) => row.id === id) },
-        };
-    }, undefined, undefined, dataruleRollbackSpec("datarule.delete"));
+    writeTool({
+        tools,
+        name: "datarule.create",
+        lane: DATARULE_LANE,
+        scope: DATARULE_TOOLS["datarule.create"].scope,
+        description: DATARULE_TOOLS["datarule.create"].description,
+        inputSchema: {
+            schemaCode: z.string().min(1),
+            propertyCode: propertyCodeArg,
+            propertyCodes: propertyCodesArg,
+            dataRuleType: dataRuleTypeArg,
+            options: dataRuleOptionsArg,
+            checkType: checkTypeArg,
+            childRule: z.boolean().optional(),
+            name: z.string().optional(),
+            sortKey: z.number().int().optional(),
+        },
+        execute: async (session, args) => {
+            assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+            assertDataRuleCheckType(args.dataRuleType, args.checkType);
+            assertDataRuleTarget(args);
+            const codes = dataRuleTargetCodes(args);
+            const published = await readPublishedFieldCodesOrNull(session, args.schemaCode);
+            await assertChildFormulaRefs(session, args, published);
+            if (published !== null) {
+                const missing = codes.filter((code) => !published.has(code));
+                if (missing.length > 0)
+                    throw new ToolRefusalError({ status: "refused", blocker: "datarule-property-not-published", schemaCode: args.schemaCode, propertyCodes: codes, missing, message: `字段 ${args.schemaCode}.${missing.join(",")} 不在发布面上；拒绝 datarule.create POST` });
+            }
+            const existingRules = await listDataRules(session, args.schemaCode);
+            // dataRuleType 1 (CHECK_RULE) fans out into 5 checkTypes that COEXIST on one
+            // field (the platform auto-creates a checkType 4 maxLength row per text
+            // field), so the clash key there is field + `checkType`, not field + type.
+            if (existingRules.some((row) => {
+                if (Number(row.dataRuleType) !== args.dataRuleType)
+                    return false;
+                if (!storedTargetCodes(row).some((code) => codes.includes(code)))
+                    return false;
+                return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
+            }))
+                throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", schemaCode: args.schemaCode, propertyCodes: codes, dataRuleType: args.dataRuleType, ...(args.dataRuleType === 1 ? { checkType: args.checkType } : {}), message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝重复 POST` });
+            const createRule = () => wireCall(session, {
+                path: ENDPOINTS.dataRuleCreate,
+                method: "POST",
+                body: dataRuleBody(args, JSON.stringify(withOptionsPropertyCodes(withStitchEditorText(args.options), codes))),
+            });
+            // Ticket 78: ONLY type2 CALCULATE has the corroborated unpublished-app
+            // FALSE dead-cycle 305003 (checkCalculateRulesDeadCycle mis-concatenates
+            // schemaCode.propertyCode when getAppFunctionByCode is null); types
+            // 3/4/5 keep the plain wire failure.
+            const performed = args.dataRuleType === 2
+                ? await runtimeWriteWithAppMapping(session, args.schemaCode, 305003, "datarule.create 类型2 CALCULATE 报死循环（305003，误判）", createRule)
+                : await createRule();
+            const rules = (await listDataRules(session, args.schemaCode, args.dataRuleType)).filter((row) => storedTargetCodes(row).some((code) => codes.includes(code)));
+            return {
+                performed: { errcode: performed.errcode },
+                readback: {
+                    schemaCode: args.schemaCode,
+                    propertyCodes: codes,
+                    dataRuleType: args.dataRuleType,
+                    matchedCount: rules.length,
+                    rules: rules.map(decodeDataRule),
+                    ...(args.dataRuleType >= 3 ? { advisory: DATARULE_FORM_INTERACTION_ADVISORY } : {}),
+                    // r35（2026-10-31 真机）：type1 校验规则建好读回一致，但 REST `data.submit`
+                    // 提交违规数据（-50 / 超阈值）errcode 0 放行、原值落库——校验在门户前端
+                    // 提交管线执行，REST 不拦。先告知执行面，省掉「先实测两轮才发现不生效」。
+                    ...(args.dataRuleType === 1
+                        ? { executionWarning: "校验规则在门户前端提交时执行；REST `data.submit` 不拦截违规数据（r35 真机：-50 与超阈值均 errcode 0 放行）。验收拦截效果需走门户，或改用业务规则（BIZ_ACTION/条件）在服务端拦。" }
+                        : {}),
+                    ...(() => { const w = dataRuleFormulaWarnings(args.dataRuleType, args.options); return w.length ? { lintWarnings: w } : {}; })(),
+                },
+            };
+        },
+        preflight: // T-04: the type-2 shape gate is static — refuse BEFORE the write permission gate.
+        (args) => {
+            assertDataRuleTarget(args);
+            assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+            assertDataRuleCheckType(args.dataRuleType, args.checkType);
+        },
+        dryRunPayload: // Dry-run is the cheapest place to see the formula lint (the platform
+        // validates nothing at create time; the failure surfaces at submit).
+        async (_session, args) => {
+            const lintWarnings = dataRuleFormulaWarnings(args.dataRuleType, args.options);
+            return lintWarnings.length ? { lintWarnings } : {};
+        },
+        rollback: dataruleRollbackSpec("datarule.create"),
+    });
+    writeTool({
+        tools,
+        name: "datarule.update",
+        lane: DATARULE_LANE,
+        scope: DATARULE_TOOLS["datarule.update"].scope,
+        description: DATARULE_TOOLS["datarule.update"].description,
+        inputSchema: {
+            id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
+            schemaCode: z.string().min(1),
+            propertyCode: propertyCodeArg,
+            propertyCodes: propertyCodesArg,
+            dataRuleType: dataRuleTypeArg,
+            options: dataRuleOptionsArg,
+            checkType: checkTypeArg,
+            childRule: z.boolean().optional(),
+            name: z.string().optional(),
+            sortKey: z.number().int().optional(),
+        },
+        execute: async (session, args) => {
+            assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+            assertDataRuleCheckType(args.dataRuleType, args.checkType);
+            const id = await locateDataRuleId(session, args, "update POST");
+            const before = await listDataRules(session, args.schemaCode);
+            const current = before.find((row) => row.id === id);
+            if (!current)
+                throw new ToolRefusalError({ status: "refused", blocker: "datarule-absent", message: `数据规则 ${id} 不存在于 ${args.schemaCode}；拒绝 update POST` });
+            // The stored childRule governs when the caller omits it (full-row update).
+            const patchArgs = { ...args, id };
+            await assertChildFormulaRefs(session, { ...patchArgs, childRule: args.childRule ?? current.childRule === true });
+            // Keep the existing binding when the caller omits a target (the platform
+            // update is a full-row overwrite — an empty patch would clear propertyCodes).
+            const requested = dataRuleTargetCodes(patchArgs);
+            const codes = requested.length > 0 ? requested : storedTargetCodes(current);
+            const boundArgs = { ...patchArgs, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes };
+            if (before.some((row) => {
+                if (row.id === id)
+                    return false;
+                if (Number(row.dataRuleType) !== args.dataRuleType)
+                    return false;
+                if (!storedTargetCodes(row).some((code) => codes.includes(code)))
+                    return false;
+                return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
+            }))
+                throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝 update POST` });
+            const beforeDecoded = decodeDataRule(current);
+            const performed = await wireCall(session, {
+                path: ENDPOINTS.dataRuleUpdate,
+                method: "POST",
+                body: fullDataRuleBody(current, boundArgs, JSON.stringify(withOptionsPropertyCodes(withStitchEditorText(args.options), codes))),
+            });
+            const record = (await listDataRules(session, args.schemaCode, args.dataRuleType)).find((row) => row.id === id);
+            if (!record)
+                throw new WireError("business", `data rule ${id} disappeared after update`, 304001);
+            const afterDecoded = decodeDataRule(record);
+            const proof = dataRuleChanges(beforeDecoded, afterDecoded);
+            return {
+                performed: { errcode: performed.errcode },
+                readback: { id, present: true, before: beforeDecoded, after: afterDecoded, changedFields: proof.changedFields, unexpectedChanges: proof.unexpectedChanges, rule: afterDecoded },
+            };
+        },
+        preflight: (args) => {
+            assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+        },
+        rollback: dataruleRollbackSpec("datarule.update"),
+    });
+    writeTool({
+        tools,
+        name: "datarule.delete",
+        lane: DATARULE_LANE,
+        scope: DATARULE_TOOLS["datarule.delete"].scope,
+        description: DATARULE_TOOLS["datarule.delete"].description,
+        inputSchema: {
+            id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
+            schemaCode: z.string().min(1),
+            propertyCode: propertyCodeArg,
+            propertyCodes: propertyCodesArg,
+            dataRuleType: z.number().int().min(1).max(5).optional().describe("业务键定位去歧义：同一字段可能有多条规则（如必填+只读），用它指定要删的类型"),
+        },
+        execute: async (session, args) => {
+            const id = await locateDataRuleId(session, args, "delete POST");
+            const before = (await listDataRules(session, args.schemaCode)).find((row) => row.id === id);
+            const performed = await wireCall(session, {
+                path: ENDPOINTS.dataRuleDelete,
+                method: "POST",
+                query: { id },
+            });
+            const after = await listDataRules(session, args.schemaCode);
+            return {
+                performed: { errcode: performed.errcode },
+                readback: { id, existedBefore: before !== undefined, absent: !after.some((row) => row.id === id) },
+            };
+        },
+        rollback: dataruleRollbackSpec("datarule.delete"),
+    });
 }
 //# sourceMappingURL=datarule.js.map