@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/intent/capabilities/datarule.js

@@ -0,0 +1,187 @@
+import { ENDPOINTS } from "../../endpoints.js";
+import { assertDataRuleOptions } from "../../lanes/datarule.js";
+import { wireCall, wireRows } from "../../wire.js";
+import { optionalSame, sameValue } from "../compare.js";
+import { isScalarString, pushError } from "../validation.js";
+import { toPlain } from "../yaml.js";
+import { errorDetail } from "../../tool-types.js";
+const KEYS = new Set(["propertyCode", "dataRuleType", "options", "checkType", "childRule", "name", "sortKey", "absent"]);
+/** Keys that describe a live rule and are meaningless on a declared-absent one. */
+const PRESENT_ONLY_KEYS = ["options", "checkType", "childRule", "name", "sortKey"];
+function decodeOptions(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function rowOf(row) {
+    const codes = rowCodes(row);
+    return {
+        id: String(row.id ?? ""),
+        propertyCode: codes.length === 1 ? codes[0] : codes.join(","),
+        dataRuleType: Number(row.dataRuleType),
+        options: decodeOptions(row.options),
+        ...(row.checkType !== undefined && row.checkType !== null ? { checkType: Number(row.checkType) } : {}),
+        ...(row.childRule !== undefined ? { childRule: row.childRule === true } : {}),
+        ...(row.name !== undefined && row.name !== null ? { name: String(row.name) } : {}),
+        // The platform defaults an omitted sortKey to 0; an intent that omits it must
+        // read back equal (bench56: `sortKey:0` vs undefined produced a perpetual
+        // `datarule-mismatch`, so a fully-delivered apply was reported refused).
+        ...(row.sortKey !== undefined && row.sortKey !== null && Number(row.sortKey) !== 0 ? { sortKey: Number(row.sortKey) } : {}),
+    };
+}
+function normalizeOptions(dataRuleType, options, propertyCode) {
+    const normalized = { ...options };
+    // The tool mirrors the target field(s) into options.propertyCodes (the real
+    // designer shape the engine reads); declare the same here so a converged
+    // environment has no false drift.
+    if (propertyCode.length > 0 && normalized.propertyCodes === undefined)
+        normalized.propertyCodes = propertyCode;
+    if (dataRuleType === 2) {
+        for (const key of ["shortTextStitch", "value", "aggregation"]) {
+            if (normalized[key] !== undefined && typeof normalized[key] === "object")
+                normalized[key] = JSON.stringify(normalized[key]);
+        }
+    }
+    return normalized;
+}
+/** Stored target field codes (propertyCodes array preferred, legacy singular fallback). */
+function rowCodes(row) {
+    if (Array.isArray(row.propertyCodes) && row.propertyCodes.length > 0)
+        return row.propertyCodes.map((code) => String(code));
+    const single = row.propertyCode;
+    return single !== undefined && single !== null && String(single).length > 0 ? [String(single)] : [];
+}
+export const dataruleCapability = {
+    id: "datarule",
+    title: "字段级控件规则",
+    requires: ["field"],
+    operations: ["create", "update"],
+    validate(node, draft, ctx) {
+        const rulesNode = node.entries.find((entry) => entry.key === "datarules")?.value;
+        if (rulesNode === undefined || (rulesNode.kind === "scalar" && rulesNode.value === null))
+            return;
+        if (rulesNode.kind !== "seq") {
+            pushError(ctx, "intent-datarules-not-a-list", "datarules 必须是列表", `${ctx.base}.datarules`, "value");
+            return;
+        }
+        rulesNode.items.forEach((ruleNode, index) => {
+            const base = `${ctx.base}.datarules[${index}]`;
+            if (ruleNode.kind !== "map") {
+                pushError(ctx, "intent-datarule-not-a-map", "datarule 必须是映射", base, "value");
+                return;
+            }
+            for (const entry of ruleNode.entries)
+                if (!KEYS.has(entry.key))
+                    pushError(ctx, "intent-key-unknown", `datarule 不支持键 "${entry.key}"（可用：${[...KEYS].join(" / ")}）`, `${base}.${entry.key}`);
+            const get = (key) => ruleNode.entries.find((entry) => entry.key === key)?.value;
+            const property = get("propertyCode");
+            const type = get("dataRuleType");
+            const options = get("options");
+            const checkType = get("checkType");
+            const childRule = get("childRule");
+            const name = get("name");
+            const sortKey = get("sortKey");
+            const absent = get("absent");
+            if (!isScalarString(property) || property.value.trim().length === 0)
+                pushError(ctx, "intent-datarule-property-invalid", "datarule.propertyCode 必须是非空字符串", `${base}.propertyCode`, "value");
+            if (type?.kind !== "scalar" || typeof type.value !== "number" || !Number.isInteger(type.value) || type.value < 1 || type.value > 5)
+                pushError(ctx, "intent-datarule-type-invalid", "datarule.dataRuleType 必须是 1..5", `${base}.dataRuleType`, "value");
+            if (absent !== undefined && (absent.kind !== "scalar" || typeof absent.value !== "boolean"))
+                pushError(ctx, "intent-datarule-absent-invalid", "datarule.absent 必须是布尔", `${base}.absent`, "value");
+            if (absent?.kind === "scalar" && absent.value === true) {
+                for (const key of PRESENT_ONLY_KEYS)
+                    if (ruleNode.entries.some((entry) => entry.key === key))
+                        pushError(ctx, "intent-datarule-absent-with-shape", `数据规则声明 absent:true 表示删除该规则，不能再声明 ${key}`, `${base}.${key}`);
+                if (isScalarString(property) && type?.kind === "scalar" && typeof type.value === "number")
+                    draft.datarules.push({ propertyCode: property.value.trim(), dataRuleType: type.value, absent: true });
+                return;
+            }
+            if (options?.kind !== "map")
+                pushError(ctx, "intent-datarule-options-invalid", "datarule.options 必须是映射", `${base}.options`, "value");
+            if (checkType !== undefined && (checkType.kind !== "scalar" || typeof checkType.value !== "number"))
+                pushError(ctx, "intent-datarule-checktype-invalid", "datarule.checkType 必须是数字", `${base}.checkType`, "value");
+            if (childRule !== undefined && (childRule.kind !== "scalar" || typeof childRule.value !== "boolean"))
+                pushError(ctx, "intent-datarule-childrule-invalid", "datarule.childRule 必须是布尔", `${base}.childRule`, "value");
+            if (name !== undefined && (!isScalarString(name) || name.value.trim().length === 0))
+                pushError(ctx, "intent-datarule-name-invalid", "datarule.name 必须是非空字符串", `${base}.name`, "value");
+            if (sortKey !== undefined && (sortKey.kind !== "scalar" || typeof sortKey.value !== "number"))
+                pushError(ctx, "intent-datarule-sortkey-invalid", "datarule.sortKey 必须是数字", `${base}.sortKey`, "value");
+            if (!isScalarString(property) || type?.kind !== "scalar" || typeof type.value !== "number" || options?.kind !== "map")
+                return;
+            const rawOptions = options.entries ? Object.fromEntries(options.entries.map((entry) => [entry.key, entry.value.kind === "scalar" ? entry.value.value : toPlain(entry.value)])) : {};
+            const normalizedOptions = normalizeOptions(type.value, rawOptions, property.value.trim());
+            const parsedCheckType = checkType?.kind === "scalar" && typeof checkType.value === "number" ? checkType.value : undefined;
+            try {
+                assertDataRuleOptions(type.value, normalizedOptions, parsedCheckType);
+            }
+            catch (error) {
+                pushError(ctx, "intent-datarule-options-invalid", errorDetail(error), `${base}.options`, "value");
+                return;
+            }
+            const item = {
+                propertyCode: property.value.trim(),
+                dataRuleType: type.value,
+                options: normalizedOptions,
+                ...(checkType?.kind === "scalar" && typeof checkType.value === "number" ? { checkType: checkType.value } : {}),
+                ...(childRule?.kind === "scalar" && typeof childRule.value === "boolean" ? { childRule: childRule.value } : {}),
+                ...(isScalarString(name) ? { name: name.value.trim() } : {}),
+                ...(sortKey?.kind === "scalar" && typeof sortKey.value === "number" ? { sortKey: sortKey.value } : {}),
+            };
+            draft.datarules.push(item);
+        });
+    },
+    async read(session, intent, draft) {
+        if (!intent.datarules?.length)
+            return;
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.dataRuleList, query: { schemaCode: draft.code } })).data);
+        draft.datarules = rows.filter((row) => row.schemaCode === draft.code && intent.datarules.some((rule) => rowCodes(row).includes(rule.propertyCode) && rule.dataRuleType === Number(row.dataRuleType))).map(rowOf);
+    },
+    plan(intent, baseline, emit) {
+        if (!intent.datarules?.length)
+            return;
+        for (const rule of intent.datarules) {
+            const current = (baseline.datarules ?? []).find((row) => row.propertyCode === rule.propertyCode && row.dataRuleType === rule.dataRuleType);
+            const resource = `datarule:${intent.code}.${rule.propertyCode}.${rule.dataRuleType}`;
+            if (rule.absent === true) {
+                if (current)
+                    emit.change("datarule.delete", { id: current.id, schemaCode: intent.code }, resource, "datarule-declared-absent");
+                else
+                    emit.skip(resource, "datarule-already-absent");
+                continue;
+            }
+            if (!current)
+                emit.change("datarule.create", { schemaCode: intent.code, ...rule }, resource, "datarule-absent");
+            else if (!sameValue(current.options, rule.options) || !optionalSame(current.checkType, rule.checkType) || !optionalSame(current.childRule, rule.childRule) || !optionalSame(current.name, rule.name) || !optionalSame(current.sortKey, rule.sortKey))
+                emit.change("datarule.update", { id: current.id, schemaCode: intent.code, ...rule }, resource, "datarule-drift");
+            else
+                emit.skip(resource, "datarule-present");
+        }
+    },
+    decode(baseline, draft) {
+        draft.datarules = (baseline.datarules ?? []).map((rule) => ({ ...rule }));
+    },
+    compare(intent, live, emit) {
+        if (!intent.datarules?.length)
+            return;
+        const current = live.datarules ?? [];
+        for (const rule of intent.datarules) {
+            const row = current.find((item) => item.propertyCode === rule.propertyCode && item.dataRuleType === rule.dataRuleType);
+            const resource = `datarule:${intent.code}.${rule.propertyCode}.${rule.dataRuleType}`;
+            if (rule.absent === true) {
+                if (row)
+                    emit.difference("datarule-present-unexpected", resource, `字段 ${intent.code}.${rule.propertyCode} 的数据规则声明 absent:true 但仍存在`);
+                continue;
+            }
+            if (!row)
+                emit.difference("datarule-missing", resource, `字段 ${intent.code}.${rule.propertyCode} 的数据规则不存在`);
+            else if (!sameValue(row.options, rule.options) || !optionalSame(row.checkType, rule.checkType) || !optionalSame(row.childRule, rule.childRule) || !optionalSame(row.name, rule.name) || !optionalSame(row.sortKey, rule.sortKey))
+                emit.difference("datarule-mismatch", resource, `字段 ${intent.code}.${rule.propertyCode} 的数据规则不等价`);
+        }
+    },
+};
+//# sourceMappingURL=datarule.js.map