@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/chunk-DM4OMPWK.js

@@ -0,0 +1,584 @@
+import {
+  feedback,
+  scorer
+} from "./chunk-IHTWQEDR.js";
+import {
+  domainMeta
+} from "./chunk-FMPF42Q4.js";
+
+// src/utils/domain-templates/index.ts
+import { batch, node } from "@graphrefly/pure-ts/core";
+import { reactiveLog, stratify } from "@graphrefly/pure-ts/extra";
+import { Graph } from "@graphrefly/pure-ts/graph";
+import { keepalive } from "@graphrefly/pure-ts/extra";
+function baseMeta(kind, extra) {
+  return domainMeta("domain_template", kind, extra);
+}
+function observabilityGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add(opts.source, { name: "source" });
+  const defaultBranches = [
+    { name: "errors", classify: (v) => isTagged(v, "error") },
+    { name: "traces", classify: (v) => isTagged(v, "trace") },
+    { name: "metrics", classify: (v) => isTagged(v, "metric") }
+  ];
+  const branches = opts.branches ?? defaultBranches;
+  const rules = branches.map((b) => ({
+    name: b.name,
+    classify: b.classify
+  }));
+  const strat = stratify("stratify", opts.source, rules);
+  g.mount("stratify", strat);
+  const branchNodes = branches.map((b) => {
+    try {
+      const raw = g.resolve(`stratify::branch/${b.name}`);
+      return node(
+        [raw],
+        (batchData, actions, ctx) => {
+          const data = batchData.map(
+            (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+          );
+          actions.emit(data[0]);
+        },
+        { initial: null, describeKind: "derived" }
+      );
+    } catch {
+      return node([], { initial: null });
+    }
+  });
+  const correlateFn = opts.correlate ?? ((vals) => vals);
+  const correlateNode = node(
+    branchNodes,
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(correlateFn(vals));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("observability", { stage: "correlate" })
+    }
+  );
+  g.add(correlateNode, { name: "correlate" });
+  const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
+  const sloValue = node(
+    [correlateNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0]);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("observability", { stage: "slo_value" })
+    }
+  );
+  const sloVerified = node(
+    [sloValue],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(sloCheckFn(data[0]));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("observability", { stage: "slo_verified" })
+    }
+  );
+  g.add(sloValue, { name: "slo_value" });
+  g.add(sloVerified, { name: "slo_verified" });
+  const weightValues = opts.weights ?? branches.map(() => 1);
+  const signalNodes = branchNodes.map(
+    (bn) => node(
+      [bn],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(data[0] != null ? 1 : 0);
+      },
+      { describeKind: "derived" }
+    )
+  );
+  const weightNodes = weightValues.map((w) => node([], { initial: w }));
+  for (let i = 0; i < signalNodes.length; i++) {
+    g.add(signalNodes[i], { name: `__signal_${i}` });
+    g.add(weightNodes[i], { name: `__weight_${i}` });
+  }
+  const alerts = scorer(
+    signalNodes,
+    weightNodes
+  );
+  g.add(alerts, { name: "alerts" });
+  const output = node(
+    [alerts, sloVerified],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        scored: vals[0],
+        slo: vals[1]
+      });
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("observability", { stage: "output" })
+    }
+  );
+  g.add(output, { name: "output" });
+  const fbReentry = node([], {
+    initial: null,
+    meta: baseMeta("observability", { stage: "feedback_reentry" })
+  });
+  g.add(fbReentry, { name: "feedback_reentry" });
+  const fbCondition = node(
+    [sloVerified],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const result = data[0];
+      actions.emit(result && result.pass === false ? result : null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("observability", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "feedback_reentry", {
+    maxIterations: opts.maxFeedbackIterations ?? 5
+  });
+  return g;
+}
+function issueTrackerGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add(opts.source, { name: "source" });
+  let _issueCounter = 0;
+  const defaultExtract = (raw) => ({
+    id: `issue-${++_issueCounter}`,
+    title: String(raw),
+    severity: 1,
+    source: "unknown",
+    raw
+  });
+  const extractFn = opts.extract ?? defaultExtract;
+  const extractNode = node(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(extractFn(data[0]));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("issue_tracker", { stage: "extract" })
+    }
+  );
+  g.add(extractNode, { name: "extract" });
+  const verifyFn = opts.verify ?? (() => ({ valid: true }));
+  const verifyNode = node(
+    [extractNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const issue = data[0];
+      actions.emit({ issue, verification: verifyFn(issue) });
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("issue_tracker", { stage: "verify" })
+    }
+  );
+  g.add(verifyNode, { name: "verify" });
+  const knownPatterns = node([], {
+    initial: [],
+    meta: baseMeta("issue_tracker", { stage: "known_patterns" })
+  });
+  g.add(knownPatterns, { name: "known_patterns" });
+  const detectFn = opts.detectRegression ?? (() => ({ regression: false }));
+  const regressionNode = node(
+    [extractNode, knownPatterns],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const issue = data[0];
+      const known = data[1];
+      actions.emit({ issue, regression: detectFn(issue, known) });
+    },
+    { describeKind: "derived", meta: baseMeta("issue_tracker", { stage: "regression" }) }
+  );
+  g.add(regressionNode, { name: "regression" });
+  const severitySignal = node(
+    [extractNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const issue = data[0];
+      actions.emit(issue?.severity ?? 0);
+    },
+    { describeKind: "derived" }
+  );
+  const regressionSignal = node(
+    [regressionNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const r = data[0];
+      actions.emit(r?.regression ? 2 : 0);
+    },
+    { describeKind: "derived" }
+  );
+  g.add(severitySignal, { name: "__severity_signal" });
+  g.add(regressionSignal, { name: "__regression_signal" });
+  const severityWeight = node([], { initial: 1 });
+  const regressionWeight = node([], { initial: 1.5 });
+  g.add(severityWeight, { name: "__severity_weight" });
+  g.add(regressionWeight, { name: "__regression_weight" });
+  const priority = scorer([severitySignal, regressionSignal], [severityWeight, regressionWeight]);
+  g.add(priority, { name: "priority" });
+  const output = node(
+    [verifyNode, regressionNode, priority],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        verified: vals[0],
+        regression: vals[1],
+        priority: vals[2]
+      });
+    },
+    { describeKind: "derived", meta: baseMeta("issue_tracker", { stage: "output" }) }
+  );
+  g.add(output, { name: "output" });
+  const fbReentry = node([], {
+    initial: null,
+    meta: baseMeta("issue_tracker", { stage: "feedback_reentry" })
+  });
+  g.add(fbReentry, { name: "feedback_reentry" });
+  const fbCondition = node(
+    [verifyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const result = data[0];
+      if (result) {
+        const v = result.verification;
+        if (v && v.valid === false) {
+          actions.emit(result);
+          return;
+        }
+      }
+      actions.emit(null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("issue_tracker", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "feedback_reentry", {
+    maxIterations: opts.maxFeedbackIterations ?? 3
+  });
+  return g;
+}
+function contentModerationGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add(opts.source, { name: "source" });
+  const defaultClassify = (content) => ({
+    label: "review",
+    confidence: 0.5,
+    original: content
+  });
+  const classifyFn = opts.classify ?? defaultClassify;
+  const classifyNode = node(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(classifyFn(data[0]));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("content_moderation", { stage: "classify" })
+    }
+  );
+  g.add(classifyNode, { name: "classify" });
+  const strat = stratify("stratify", classifyNode, [
+    { name: "safe", classify: (v) => v.label === "safe" },
+    { name: "review", classify: (v) => v.label === "review" },
+    { name: "block", classify: (v) => v.label === "block" }
+  ]);
+  g.mount("stratify", strat);
+  const reviewLog = reactiveLog([], {
+    name: "review_queue",
+    maxSize: opts.maxQueueSize
+  });
+  g.add(reviewLog.entries, { name: "review_queue" });
+  let reviewBranch;
+  try {
+    reviewBranch = g.resolve("stratify::branch/review");
+  } catch {
+    reviewBranch = node([], { initial: null });
+    g.add(reviewBranch, { name: "__review_fallback" });
+  }
+  const reviewAccumulator = node(
+    [reviewBranch],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const item = data[0];
+      if (item) {
+        reviewLog.append(item);
+      }
+    },
+    { describeKind: "effect" }
+  );
+  g.add(reviewAccumulator, { name: "__review_accumulator" });
+  g.addDisposer(keepalive(reviewAccumulator));
+  try {
+  } catch {
+  }
+  const policy = node([], {
+    initial: {},
+    meta: baseMeta("content_moderation", {
+      stage: "policy",
+      access: "both",
+      description: "Moderation policy rules \u2014 updated via feedback"
+    })
+  });
+  g.add(policy, { name: "policy" });
+  const weights = opts.weights ?? [0.1, 1, 2];
+  const confidenceSignal = node(
+    [classifyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const r = data[0];
+      actions.emit(r?.confidence ?? 0);
+    },
+    { describeKind: "derived" }
+  );
+  const severitySignal = node(
+    [classifyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const r = data[0];
+      if (!r) {
+        actions.emit(0);
+        return;
+      }
+      actions.emit(
+        r.label === "block" ? weights[2] : r.label === "review" ? weights[1] : weights[0]
+      );
+    },
+    { describeKind: "derived" }
+  );
+  g.add(confidenceSignal, { name: "__confidence_signal" });
+  g.add(severitySignal, { name: "__severity_signal" });
+  const wConfidence = node([], { initial: 1 });
+  const wSeverity = node([], { initial: 1 });
+  g.add(wConfidence, { name: "__w_confidence" });
+  g.add(wSeverity, { name: "__w_severity" });
+  const priority = scorer([confidenceSignal, severitySignal], [wConfidence, wSeverity]);
+  g.add(priority, { name: "priority" });
+  const output = node(
+    [classifyNode, priority],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        classification: vals[0],
+        priority: vals[1]
+      });
+    },
+    { describeKind: "derived", meta: baseMeta("content_moderation", { stage: "output" }) }
+  );
+  g.add(output, { name: "output" });
+  const fbCondition = node(
+    [reviewLog.entries, policy],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const entries = vals[0];
+      if (entries && entries.length > 0) {
+        const latest = entries[entries.length - 1];
+        if (latest && latest.falsePositive) {
+          actions.emit(latest);
+          return;
+        }
+      }
+      actions.emit(null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("content_moderation", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "policy", {
+    maxIterations: opts.maxFeedbackIterations ?? 5
+  });
+  return g;
+}
+function dataQualityGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add(opts.source, { name: "source" });
+  const validateFn = opts.validate ?? ((record) => ({
+    valid: true,
+    errors: [],
+    record
+  }));
+  const validateNode = node(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0] != null ? validateFn(data[0]) : void 0);
+    },
+    { describeKind: "derived", meta: baseMeta("data_quality", { stage: "validate" }) }
+  );
+  g.add(validateNode, { name: "validate" });
+  const detectAnomalyFn = opts.detectAnomaly ?? ((record) => ({
+    anomaly: false,
+    score: 0,
+    record
+  }));
+  const anomalyNode = node(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0] != null ? detectAnomalyFn(data[0]) : void 0);
+    },
+    { describeKind: "derived", meta: baseMeta("data_quality", { stage: "anomaly" }) }
+  );
+  g.add(anomalyNode, { name: "anomaly" });
+  const baseline = node([], {
+    initial: null,
+    meta: baseMeta("data_quality", {
+      stage: "baseline",
+      description: "Rolling baseline for drift detection"
+    })
+  });
+  g.add(baseline, { name: "baseline" });
+  const baselineUpdater = node(
+    [validateNode],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const result = data[0];
+      if (result?.valid) {
+        batch(() => {
+          baseline.emit(result.record);
+        });
+      }
+    },
+    { describeKind: "effect" }
+  );
+  g.add(baselineUpdater, { name: "__baseline_updater" });
+  keepalive(baselineUpdater);
+  const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
+  const driftNode = node(
+    [opts.source, baseline],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(detectDriftFn(data[0], data[1]));
+    },
+    { describeKind: "derived", meta: baseMeta("data_quality", { stage: "drift" }) }
+  );
+  g.add(driftNode, { name: "drift" });
+  const suggestFn = opts.suggest ?? (() => null);
+  const remediateNode = node(
+    [validateNode, anomalyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(
+        suggestFn({
+          validation: data[0],
+          anomaly: data[1]
+        })
+      );
+    },
+    { describeKind: "derived", meta: baseMeta("data_quality", { stage: "remediate" }) }
+  );
+  g.add(remediateNode, { name: "remediate" });
+  const output = node(
+    [validateNode, anomalyNode, driftNode, remediateNode],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        validation: vals[0],
+        anomaly: vals[1],
+        drift: vals[2],
+        remediation: vals[3]
+      });
+    },
+    { describeKind: "derived", meta: baseMeta("data_quality", { stage: "output" }) }
+  );
+  g.add(output, { name: "output" });
+  const validationRules = node([], {
+    initial: [],
+    meta: baseMeta("data_quality", { stage: "validation_rules" })
+  });
+  g.add(validationRules, { name: "validation_rules" });
+  const fbCondition = node(
+    [anomalyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const a = data[0];
+      actions.emit(a?.anomaly ? a : null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta("data_quality", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "validation_rules", {
+    maxIterations: opts.maxFeedbackIterations ?? 3
+  });
+  return g;
+}
+function isTagged(value, tag) {
+  if (value == null || typeof value !== "object") return false;
+  const v = value;
+  return v.type === tag || v.kind === tag;
+}
+
+export {
+  observabilityGraph,
+  issueTrackerGraph,
+  contentModerationGraph,
+  dataQualityGraph
+};
+//# sourceMappingURL=chunk-DM4OMPWK.js.map