atris 3.75.0 → 3.76.0

package/lib/review-integrity.js

@@ -59,20 +59,65 @@ function reviewEventActors(task) {
   return actors;
 }
 
-// Actors who reviewed the task and are not its builder.
+// Everyone who ever built the task: the stamped builder, the current claimant, whoever any claim
+// event on file names, and whoever handed work in on it (the proof_ready events that carry a
+// handed_in_by mark; a review pass leaves none) together with the others that hand-in names as
+// having built the work with it (its built_with list: a flight that ran for a member hands in under
+// the member's name, and the engines that ran are named there). Authorship is cumulative and nothing clears it, so
+// sending a job back, letting the claim go or reopening it never makes a past builder look
+// independent again. The system's own names (RESERVED_ACTORS) record passes and checks, never
+// builds, so an event under one of them makes no author. `task.events` is whatever the caller has
+// of the job's history; a caller with the whole history (the store's authorsOfTask) gets the whole
+// answer.
+function taskAuthors(task) {
+  const authors = new Set();
+  if (!task || typeof task !== 'object') return authors;
+  const add = (value, { fromEvent = false } = {}) => {
+    const name = normalizeActor(value);
+    if (name && !(fromEvent && RESERVED_ACTORS.has(name))) authors.add(name);
+  };
+  const metadata = task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  add(metadata.built_by);
+  add(task.claimed_by);
+  const events = Array.isArray(task.events) ? task.events : [];
+  for (const event of events) {
+    if (!event || typeof event !== 'object') continue;
+    const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
+    if (event.event_type === 'claimed') add(payload.claimed_by || event.actor, { fromEvent: true });
+    else if (event.event_type === 'proof_ready') {
+      add(payload.handed_in_by, { fromEvent: true });
+      // A list of names, not a string to split; anything in it that is not a name is no author.
+      if (Array.isArray(payload.built_with)) {
+        for (const name of payload.built_with) if (typeof name === 'string') add(name, { fromEvent: true });
+      }
+    }
+  }
+  return authors;
+}
+
+// Whether this actor ever built the task (see taskAuthors), or is the builder the older rules
+// resolve for a row with no other record (taskBuilder).
+function isTaskAuthor(task, actor) {
+  const name = normalizeActor(actor);
+  if (!name || !task || typeof task !== 'object') return false;
+  return taskAuthors(task).has(name) || taskBuilder(task) === name;
+}
+
+// Actors who reviewed the task and never built any of it.
 function independentReviewActors(task) {
   const builder = taskBuilder(task);
   const actors = reviewEventActors(task);
   if (builder) actors.delete(builder);
+  for (const author of taskAuthors(task)) actors.delete(author);
   return actors;
 }
 
-// True when at least one review pass came from someone other than the
-// builder. When the builder cannot be resolved at all, fall back to
-// requiring two distinct actors. Independence cannot be proven from one.
+// True when at least one review pass came from someone who never built any of the task. When
+// nobody can be resolved as its builder at all, fall back to requiring two distinct actors.
+// Independence cannot be proven from one.
 function hasIndependentReview(task) {
   const builder = taskBuilder(task);
-  if (!builder) return reviewEventActors(task).size >= 2;
+  if (!builder && taskAuthors(task).size === 0) return reviewEventActors(task).size >= 2;
   return independentReviewActors(task).size >= 1;
 }
 
@@ -138,6 +183,8 @@ module.exports = {
   normalizeActor,
   isFleetEngineActor,
   taskBuilder,
+  taskAuthors,
+  isTaskAuthor,
   reviewEventActors,
   independentReviewActors,
   hasIndependentReview,