@contractspec/example.kb-update-pipeline 1.56.1 → 1.58.0

package/dist/node/handlers/memory.handlers.js

@@ -0,0 +1,109 @@
+// src/handlers/memory.handlers.ts
+function createPipelineMemoryStore() {
+  return {
+    candidates: new Map,
+    reviewTasks: new Map,
+    proposedRuleVersionIdsByCandidate: new Map,
+    approvedRuleVersionIds: new Set,
+    notifications: []
+  };
+}
+function stableId(prefix, value) {
+  return `${prefix}_${value.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function createPipelineMemoryHandlers(store) {
+  async function runWatch(input) {
+    const candidates = [...store.candidates.values()].filter((c) => c.sourceDocumentId.startsWith(`${input.jurisdiction}_`) || true);
+    return { candidates };
+  }
+  async function createReviewTask(input) {
+    const candidate = store.candidates.get(input.changeCandidateId);
+    if (!candidate)
+      throw new Error("CHANGE_CANDIDATE_NOT_FOUND");
+    const assignedRole = candidate.riskLevel === "high" ? "expert" : "curator";
+    const id = stableId("review", input.changeCandidateId);
+    const task = {
+      id,
+      changeCandidateId: input.changeCandidateId,
+      status: "open",
+      assignedRole,
+      decision: undefined,
+      decidedAt: undefined,
+      decidedBy: undefined
+    };
+    store.reviewTasks.set(id, task);
+    store.notifications.push({
+      kind: "kb.review.requested",
+      reviewTaskId: id,
+      changeCandidateId: input.changeCandidateId,
+      assignedRole,
+      createdAt: new Date
+    });
+    return task;
+  }
+  async function proposeRulePatch(input) {
+    if (!store.candidates.has(input.changeCandidateId)) {
+      throw new Error("CHANGE_CANDIDATE_NOT_FOUND");
+    }
+    store.proposedRuleVersionIdsByCandidate.set(input.changeCandidateId, [
+      ...input.proposedRuleVersionIds
+    ]);
+    return { proposedRuleVersionIds: [...input.proposedRuleVersionIds] };
+  }
+  async function markRuleVersionApproved(input) {
+    store.approvedRuleVersionIds.add(input.ruleVersionId);
+    return { ruleVersionId: input.ruleVersionId };
+  }
+  async function submitDecision(input) {
+    const task = store.reviewTasks.get(input.reviewTaskId);
+    if (!task)
+      throw new Error("REVIEW_TASK_NOT_FOUND");
+    const candidate = store.candidates.get(task.changeCandidateId);
+    if (!candidate)
+      throw new Error("CHANGE_CANDIDATE_NOT_FOUND");
+    if (candidate.riskLevel === "high" && input.decision === "approve") {
+      if (input.decidedByRole !== "expert")
+        throw new Error("FORBIDDEN_ROLE");
+    }
+    const decided = {
+      ...task,
+      status: "decided",
+      decision: input.decision,
+      decidedAt: new Date,
+      decidedBy: input.decidedBy
+    };
+    store.reviewTasks.set(decided.id, decided);
+    return decided;
+  }
+  async function publishIfReady(_input) {
+    const openTasks = [...store.reviewTasks.values()].filter((t) => t.status !== "decided");
+    if (openTasks.length) {
+      throw new Error("NOT_READY");
+    }
+    const rejected = [...store.reviewTasks.values()].some((t) => t.decision === "reject");
+    if (rejected)
+      return { published: false, reason: "REJECTED" };
+    for (const task of store.reviewTasks.values()) {
+      if (task.decision !== "approve")
+        continue;
+      const proposed = store.proposedRuleVersionIdsByCandidate.get(task.changeCandidateId) ?? [];
+      const unapproved = proposed.filter((id) => !store.approvedRuleVersionIds.has(id));
+      if (unapproved.length) {
+        throw new Error("NOT_READY");
+      }
+    }
+    return { published: true };
+  }
+  return {
+    runWatch,
+    createReviewTask,
+    proposeRulePatch,
+    markRuleVersionApproved,
+    submitDecision,
+    publishIfReady
+  };
+}
+export {
+  createPipelineMemoryStore,
+  createPipelineMemoryHandlers
+};