Skip to content

World's first open-source enterprise world model.

Show potential inputs and consumers of rule definitions (#830)

Maya Kidc65d7b4c2613
diff --git a/web/src/i18n/en.ts b/web/src/i18n/en.ts
index a84edb05..c3282f75 100644
--- a/web/src/i18n/en.ts
+++ b/web/src/i18n/en.ts
@@ -1224,6 +1224,12 @@ export const en = {
rulesShort: "Business rules",
ruleExpressionReadOnly: "This definition is read-only in this form. You can edit its name and description without changing its expressions or conditions.",
ruleUnknownExpression: "Unsupported expression (read-only)",
+ ruleDependencies: "Potential dependencies",
+ ruleDependenciesHint: "Candidates from rule definitions, not proof of execution. Readings, conditions and time determine what actually runs; disabled definitions are included.",
+ ruleDependenciesIncomplete: "Some definitions or classes could not be read completely. This list may be incomplete.",
+ rulePotentialProducers: "May receive input from",
+ rulePotentialConsumers: "May provide input to",
+ ruleDependenciesEmpty: "No candidates found in the readable definitions.",
rulesTitle: "Business rules",
/* 说清三件事:谁写的、结论是什么身份、什么时候重算。第三件最容易被误解成
「保存就生效」,而它其实等下一轮物化 */
diff --git a/web/src/i18n/zh.ts b/web/src/i18n/zh.ts
index 67593ffb..b809c1a7 100644
--- a/web/src/i18n/zh.ts
+++ b/web/src/i18n/zh.ts
@@ -1100,6 +1100,12 @@ export const zh: Strings = {
rulesShort: "业务规则",
ruleExpressionReadOnly: "此表单只读展示这条规则的定义。可修改名称和说明,表达式和条件保持原样。",
ruleUnknownExpression: "暂不支持的表达式(只读)",
+ ruleDependencies: "潜在依赖",
+ ruleDependenciesHint: "根据规则定义列出的候选关系,不代表实际执行。读数、条件和时间决定哪些规则成立;这里也包括已停用的定义。",
+ ruleDependenciesIncomplete: "部分定义或类信息无法完整读取,此列表可能不完整。",
+ rulePotentialProducers: "可能从这些规则获得输入",
+ rulePotentialConsumers: "可能为这些规则提供输入",
+ ruleDependenciesEmpty: "在可读取的定义中未找到候选关系。",
rulesTitle: "业务规则",
rulesHint: "按实体自己的属性判定类别、或算出取值的规则。结论是派生的,依据没了就自动失效。",
rulesEmpty: "还没有规则。",
diff --git a/web/src/pages/RulesPanel.tsx b/web/src/pages/RulesPanel.tsx
index f04245ae..40845d16 100644
--- a/web/src/pages/RulesPanel.tsx
+++ b/web/src/pages/RulesPanel.tsx
@@ -8,7 +8,7 @@
*
* 样式按 web/DESIGN.md 那五条:字号五档、间距六档、颜色只用 token、控件与状态
* 一律从 ui/ 来。 */
-import { useEffect, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { Pencil, Play, Plus, Search, Trash2 } from "lucide-react";
import {
@@ -40,6 +40,7 @@ import {
} from "../ui";
import { toast } from "../toast";
import { expressionText, metadataOnly, metadataPatch } from "./ruleExpressions";
+import { ruleDependencies } from "./ruleDependencies";
/** op → 那句话里的动词。**数字与集合两类分开**,因为它们的操作数长得不一样 */
const OPS: {
@@ -258,6 +259,15 @@ export function RulesPanel({
/** 展开了哪条规则的命中列表。一次只展开一条——两份长列表并排读不了 */
const [opened, setOpened] = useState<string | null>(null);
const [filter, setFilter] = useState("");
+ const [dependenciesOf, setDependenciesOf] = useState<string | null>(null);
+ const [navigation, setNavigation] = useState<{ id: string } | null>(null);
+ useEffect(() => { setDependenciesOf(null); setNavigation(null); }, [kbId]);
+ useEffect(() => {
+ if (!navigation) return;
+ const row = document.getElementById(`rule-${kbId}-${navigation.id}`);
+ row?.scrollIntoView({ block: "center" });
+ row?.focus();
+ }, [kbId, navigation]);
const invalidate = () => {
qc.invalidateQueries({ queryKey: ["rules", kbId] });
@@ -344,6 +354,11 @@ export function RulesPanel({
});
const all = rules.data?.rules ?? [];
+ const dependencies = useMemo(() => ruleDependencies(rules.data?.rules ?? [], classes, attributes), [rules.data, classes, attributes]);
+ const inspecting = all.find((r) => r.id === dependenciesOf);
+ const navigateRule = (id: string) => {
+ setFilter(""); setDependenciesOf(null); setNavigation({ id });
+ };
const needle = filter.trim().toLowerCase();
const list = needle
? all.filter((r) => searchText(r, attributes).includes(needle))
@@ -432,13 +447,16 @@ export function RulesPanel({
{list.map((r) => (
<Tr
key={r.id}
+ id={`rule-${kbId}-${r.id}`}
+ tabIndex={-1}
className={cn(
!r.enabled && "opacity-55",
- r.id === focusId && "u-picked bg-surface-2",
+ (r.id === focusId || r.id === navigation?.id) && "u-picked bg-surface-2",
)}
>
<Td>
<div className="text-body text-ink">{r.name}</div>
+ <LinkButton onClick={() => setDependenciesOf(r.id)}>{S.ontology.ruleDependencies}</LinkButton>
{r.description && (
<div className="text-fine text-ink-2">{r.description}</div>
)}
@@ -513,6 +531,17 @@ export function RulesPanel({
</div>
)}
+ <Dialog open={!!inspecting} onOpenChange={(open) => !open && setDependenciesOf(null)}
+ closeLabel={S.ui.close} title={inspecting?.name ?? ""} description={S.ontology.ruleDependenciesHint}>
+ {inspecting && <div className="space-y-4">
+ {dependencies.incomplete && <p className="text-small text-warn">{S.ontology.ruleDependenciesIncomplete}</p>}
+ <RuleDependencyList title={S.ontology.rulePotentialProducers}
+ rules={all.filter((r) => dependencies.links.get(inspecting.id)?.producers.has(r.id))} onSelect={navigateRule} />
+ <RuleDependencyList title={S.ontology.rulePotentialConsumers}
+ rules={all.filter((r) => dependencies.links.get(inspecting.id)?.consumers.has(r.id))} onSelect={navigateRule} />
+ </div>}
+ </Dialog>
+
{/* 命中:这一条此刻推出了哪些结论 */}
<Dialog
open={!!opening}
@@ -848,3 +877,15 @@ function RuleMetadataDialog({ kbId, rule, attributes, onClose, onSaved }: {
</div>
</Dialog>;
}
+
+export function RuleDependencyList({ title, rules, onSelect }: {
+ title: string; rules: BusinessRule[]; onSelect: (id: string) => void;
+}) {
+ return <section className="space-y-2">
+ <h3 className="text-body font-medium text-ink">{title}</h3>
+ {rules.length ? rules.map((r) => <div key={r.id} className="flex flex-wrap items-baseline gap-2">
+ <LinkButton onClick={() => onSelect(r.id)}>{r.name}</LinkButton>
+ <span className="text-fine text-ink-2">{r.subject_label} · {r.enabled ? S.ontology.ruleEnabled : S.ontology.ruleDisabled}</span>
+ </div>) : <p className="text-small text-ink-2">{S.ontology.ruleDependenciesEmpty}</p>}
+ </section>;
+}
diff --git a/web/src/pages/ruleDependencies.test.ts b/web/src/pages/ruleDependencies.test.ts
new file mode 100644
index 00000000..c103f47b
--- /dev/null
+++ b/web/src/pages/ruleDependencies.test.ts
@@ -0,0 +1,79 @@
+import { describe, expect, it, vi } from "vitest";
+import { Children, isValidElement, type ReactElement, type ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { BusinessRule } from "../api";
+import { ruleDependencies } from "./ruleDependencies";
+import { RuleDependencyList } from "./RulesPanel";
+import { en } from "../i18n/en";
+import { zh } from "../i18n/zh";
+const r = (id: string, patch: Partial<BusinessRule> = {}): BusinessRule => ({
+ id, name: id, subject_type_id: "root", subject_label: "Class", conclusion: "attribute",
+ conclude_predicate_id: `out-${id}`, conclude_type_label: null, conclude_predicate_label: "Value",
+ conditions: [{ predicate_id: "input", op: "gt", operand: 100 }], enabled: true, derived_count: 0, capped: 0, ...patch,
+});
+const classes = [{ id: "root", parents: [] }, { id: "child", parents: ["root"] }, { id: "leaf", parents: ["child"] }];
+describe("potential definition dependencies", () => {
+ it("finds every producer and consumer by ID, regardless of labels, thresholds or enabled state", () => {
+ const rules = [r("a", { conclude_predicate_id: "p" }), r("b", { conclude_predicate_id: "p", enabled: false }), r("c", { conditions: [{ predicate_id: "p", op: "lt", operand: -999 }] }), r("d", { conclude_predicate_id: "q" })];
+ const before = JSON.stringify(rules);
+ const { links } = ruleDependencies(rules, classes);
+ expect([...links.get("c")!.producers]).toEqual(["a", "b"]);
+ expect([...links.get("a")!.consumers]).toEqual(["c"]);
+ expect(links.get("d")!.consumers.size).toBe(0);
+ expect(JSON.stringify(rules)).toBe(before);
+ });
+ it("reads nested computed expressions and condition operands", () => {
+ const expr = { op: "div", l: { const: 2 }, r: { op: "sub", l: { attr: "p" }, r: { attr: "q" } } };
+ const computed = { ...r("computed"), conclusion: "computed", conclude_expr: expr };
+ const { links } = ruleDependencies([r("p", { conclude_predicate_id: "p" }), r("q", { conclude_predicate_id: "q" }), computed, r("operand", { conditions: [{ predicate_id: "other", op: "gt", operand: expr }] })], classes);
+ expect([...links.get("computed")!.producers]).toEqual(["p", "q"]);
+ expect([...links.get("operand")!.producers]).toEqual(["p", "q"]);
+ });
+ it("matches concluded subclasses to ancestor scopes, not the reverse", () => {
+ const { links } = ruleDependencies([r("child-output", { conclusion: "typing", conclude_type_id: "child" }), r("root-output", { conclusion: "typing", conclude_type_id: "root" }), r("child-scope", { subject_type_id: "child" }), r("leaf-scope", { subject_type_id: "leaf" })], classes);
+ expect(links.get("child-output")!.consumers.has("child-scope")).toBe(true);
+ expect(links.get("child-output")!.consumers.has("root-output")).toBe(true);
+ expect(links.get("child-output")!.consumers.has("leaf-scope")).toBe(false);
+ expect(links.get("root-output")!.consumers.has("child-scope")).toBe(false);
+ });
+ it("includes explicit readers of the built-in typing predicate", () => {
+ const { links } = ruleDependencies([r("typing", { conclusion: "typing", conclude_type_id: "child" }), r("literal", { subject_type_id: "leaf", conditions: [{ predicate_id: "is-a-id", op: "present" }] })], classes, [{ id: "is-a-id", key: "is_a" }]);
+ expect(links.get("typing")!.consumers.has("literal")).toBe(true);
+ });
+ it("preserves self-dependencies and cycles without treating them as errors", () => {
+ const { links } = ruleDependencies([r("a", { conclude_predicate_id: "input" }), r("b", { conclude_predicate_id: "input" })], classes);
+ expect([...links.get("a")!.consumers]).toEqual(["a", "b"]);
+ expect([...links.get("b")!.consumers]).toEqual(["a", "b"]);
+ });
+ it("does not reuse another snapshot and reports incomplete definitions", () => {
+ const first = ruleDependencies([r("old", { conclude_predicate_id: "input" })], classes);
+ expect(first.links.get("old")!.producers.size).toBe(1);
+ expect(ruleDependencies([], classes).links.size).toBe(0);
+ expect(ruleDependencies([{ ...r("new"), conclusion: "computed", conclude_expr: { op: "future" } }], classes).incomplete).toBe(true);
+ expect(ruleDependencies([r("new")], []).incomplete).toBe(true);
+ });
+ it("handles hierarchy cycles and all parents", () => {
+ const tree = [{ id: "x", parents: ["y", "z"] }, { id: "y", parents: ["x"] }, { id: "z", parents: [] }];
+ const { links } = ruleDependencies([r("p", { conclusion: "typing", conclude_type_id: "x", subject_type_id: "x" }), r("c", { subject_type_id: "z" })], tree);
+ expect(links.get("p")!.consumers.has("c")).toBe(true);
+ });
+ it("does not truncate a large sparse rule set", () => {
+ const rules = Array.from({ length: 10000 }, (_, i) => r(String(i), { conclude_predicate_id: `p${i}`, conditions: [{ predicate_id: `p${i-1}`, op: "present" }] }));
+ const start = performance.now();
+ const { links } = ruleDependencies(rules, classes);
+ expect(links.size).toBe(10000);
+ expect([...links.get("9999")!.producers]).toEqual(["9998"]);
+ expect([...links.values()].reduce((n, x) => n + x.consumers.size, 0)).toBe(9999);
+ expect(performance.now() - start).toBeLessThan(3000);
+ });
+ it("renders disabled definitions and navigates to the selected ID", () => {
+ const onSelect = vi.fn();
+ const element = RuleDependencyList({ title: "May receive input from", rules: [r("chosen", { enabled: false })], onSelect });
+ const markup = renderToStaticMarkup(element);
+ expect(markup).toContain("chosen"); expect(markup).toContain(en.ontology.ruleDisabled);
+ type El = ReactElement<{ children?: ReactNode; onClick?: () => void }>;
+ const walk = (e: El): void => { if (e.props.onClick) e.props.onClick(); Children.forEach(e.props.children, (c) => { if (isValidElement(c)) walk(c as El); }); };
+ walk(element as El); expect(onSelect).toHaveBeenCalledWith("chosen");
+ for (const bundle of [en, zh]) expect(bundle.ontology.ruleDependenciesHint.length).toBeGreaterThan(30);
+ });
+});
diff --git a/web/src/pages/ruleDependencies.ts b/web/src/pages/ruleDependencies.ts
new file mode 100644
index 00000000..b163e4bd
--- /dev/null
+++ b/web/src/pages/ruleDependencies.ts
@@ -0,0 +1,75 @@
+import type { BusinessRule, EntityTypeView, RelationTypeView } from "../api";
+
+type Definition = Omit<BusinessRule, "conclusion"> & { conclusion: string; conclude_expr?: unknown };
+export interface RuleLinks { producers: Set<string>; consumers: Set<string> }
+
+/** Definition-level candidates only. Conditions, time and actual readings decide
+ * which links are used in a proof. Disabled rules remain part of the definition. */
+export function ruleDependencies(rules: Definition[], classes: Pick<EntityTypeView, "id" | "parents">[], attributes: Pick<RelationTypeView, "id" | "key">[] = []) {
+ const links = new Map<string, RuleLinks>(rules.map((r) => [r.id, { producers: new Set(), consumers: new Set() }]));
+ const readers = new Map<string, Set<string>>();
+ const scopes = new Map<string, Set<string>>();
+ const parents = new Map(classes.map((c) => [c.id, c.parents]));
+ let incomplete = false;
+ const isA = attributes.find((a) => a.key === "is_a")?.id;
+ const index = (map: Map<string, Set<string>>, key: string, id: string) => {
+ if (!map.has(key)) map.set(key, new Set());
+ map.get(key)!.add(id);
+ };
+ const readExpr = (raw: unknown, id: string, depth = 0): void => {
+ if (depth > 4 || !raw || typeof raw !== "object" || Array.isArray(raw)) { incomplete = true; return; }
+ const node = raw as Record<string, unknown>;
+ if (typeof node.attr === "string") { index(readers, node.attr, id); return; }
+ if (typeof node.const === "number" || typeof node.const === "string") return;
+ if (["add", "sub", "mul", "div"].includes(String(node.op))) {
+ readExpr(node.l, id, depth + 1); readExpr(node.r, id, depth + 1);
+ } else incomplete = true;
+ };
+ for (const r of rules) {
+ index(scopes, r.subject_type_id, r.id);
+ if (!parents.has(r.subject_type_id)) incomplete = true;
+ for (const c of r.conditions) {
+ index(readers, c.predicate_id, r.id);
+ if (c.operand && typeof c.operand === "object" && !Array.isArray(c.operand)) readExpr(c.operand, r.id);
+ }
+ if (r.conclusion === "computed") readExpr(r.conclude_expr, r.id);
+ else if (!["typing", "attribute"].includes(r.conclusion)) incomplete = true;
+ }
+ const connect = (producer: string, consumers?: Set<string>) => {
+ for (const consumer of consumers ?? []) {
+ links.get(producer)!.consumers.add(consumer);
+ links.get(consumer)!.producers.add(producer);
+ }
+ };
+ const ancestorCache = new Map<string, Set<string>>();
+ const ancestors = (type: string) => {
+ const cached = ancestorCache.get(type);
+ if (cached) return cached;
+ const seen = new Set<string>(); const pending = [type];
+ while (pending.length) {
+ const id = pending.pop()!;
+ if (seen.has(id)) continue;
+ seen.add(id);
+ const ps = parents.get(id);
+ if (!ps) incomplete = true;
+ else pending.push(...ps);
+ }
+ ancestorCache.set(type, seen);
+ return seen;
+ };
+ for (const r of rules) {
+ if (r.conclusion === "typing" && r.conclude_type_id) {
+ // reasoning::attribute_rules scopes a rule to its class and descendants;
+ // therefore a concluded child can supply membership in an ancestor scope.
+ for (const type of ancestors(r.conclude_type_id)) connect(r.id, scopes.get(type));
+ // Typings also enter the literal fact pool on the built-in is_a predicate.
+ if (isA) connect(r.id, readers.get(isA));
+ } else if (["attribute", "computed"].includes(r.conclusion) && r.conclude_predicate_id) {
+ connect(r.id, readers.get(r.conclude_predicate_id));
+ // A literal is_a conclusion can also affect scope, but the ontology view
+ // does not expose every IRI the runner resolves. Do not claim completeness.
+ if (r.conclude_predicate_id === isA) incomplete = true;
+ }
+ }
+ return { links, incomplete };
+}