@goodandready/dsh-cron 0.3.1 → 0.3.2

package/lib/chain-checkpoints.js

@@ -1,11 +1,14 @@
 /**
- * Chain Checkpoint and Step Replay Manager (#319)
+ * Chain Checkpoint, Step Replay, and DAG Barrier Manager (#319, #328)
  */
 
+import { sanitizeDependsOn, sanitizeJoinPolicy } from './dag.js';
+
 export class ChainCheckpointManager {
   constructor(store) {
     this.store = store;
     this.activeRetries = new Set();
+    this.triggeredBarriers = new Set();
   }
 
   /**
@@ -48,6 +51,86 @@ export class ChainCheckpointManager {
     return this.store.chainCheckpoints[chainRunId] || [];
   }
 
+  /**
+   * Checks whether all prerequisites for a task are satisfied (DAG Join Barrier, #328).
+   *
+   * @param {string} chainRunId
+   * @param {Object} task
+   * @returns {{ ready: boolean, pending?: boolean, failed?: boolean, outputs: Record<string, string>, latestOutput: string, waitingFor?: string[], failedDep?: string }}
+   */
+  checkJoinBarrier(chainRunId, task) {
+    if (!task) return { ready: false, outputs: {}, latestOutput: '' };
+    const deps = sanitizeDependsOn(task.dependsOn);
+    if (!deps.length) {
+      return { ready: true, outputs: {}, latestOutput: '' };
+    }
+
+    const snapshots = this.getChainSnapshots(chainRunId);
+    const snapMap = new Map();
+    for (const s of snapshots) {
+      if (s?.stepTaskId) snapMap.set(s.stepTaskId, s);
+    }
+
+    const policy = sanitizeJoinPolicy(task.joinPolicy);
+    const outputs = {};
+    let latestOutput = '';
+    const waitingFor = [];
+    let hasSuccess = false;
+    let failedDep = null;
+
+    for (const depId of deps) {
+      const snap = snapMap.get(depId);
+      if (!snap) {
+        waitingFor.push(depId);
+        continue;
+      }
+      const isOk = snap.status === 'completed' || snap.status === 'success';
+      if (isOk) {
+        hasSuccess = true;
+        outputs[depId] = String(snap.output || '');
+        latestOutput = String(snap.output || '');
+      } else {
+        failedDep = depId;
+      }
+    }
+
+    if (policy === 'any_success') {
+      if (hasSuccess) {
+        return { ready: true, outputs, latestOutput };
+      }
+      if (waitingFor.length === 0) {
+        return { ready: false, failed: true, failedDep: failedDep || deps[0], outputs, latestOutput };
+      }
+      return { ready: false, pending: true, waitingFor, outputs, latestOutput };
+    }
+
+    // Default: 'all_success'
+    if (waitingFor.length > 0) {
+      return { ready: false, pending: true, waitingFor, outputs, latestOutput };
+    }
+    if (failedDep) {
+      return { ready: false, failed: true, failedDep, outputs, latestOutput };
+    }
+
+    return { ready: true, outputs, latestOutput };
+  }
+
+  /**
+   * Barrier idempotency guard: returns true if barrier has not yet fired for this task in this run.
+   */
+  canTriggerBarrier(chainRunId, taskId) {
+    if (!chainRunId || !taskId) return false;
+    return !this.triggeredBarriers.has(`${chainRunId}:${taskId}`);
+  }
+
+  /**
+   * Marks a barrier as triggered for this chain run to prevent duplicate executions.
+   */
+  markBarrierTriggered(chainRunId, taskId) {
+    if (!chainRunId || !taskId) return;
+    this.triggeredBarriers.add(`${chainRunId}:${taskId}`);
+  }
+
   /**
    * Checks whether a step can be retried in a chain run
    */
@@ -78,7 +161,7 @@ export class ChainCheckpointManager {
   }
 
   /**
-   * Retries chain execution from the specified failed step (#319)
+   * Retries chain execution from the specified failed step (#319, #328)
    * Reuses upstream outputs without re-executing successful upstream steps.
    */
   async retryChainFromStep(scheduler, chainRunId, stepTaskId) {
@@ -90,25 +173,40 @@ export class ChainCheckpointManager {
 
     try {
       const snapshots = this.getChainSnapshots(chainRunId);
-      // Find the nearest successful preceding step snapshot
-      const stepIndex = snapshots.findIndex((s) => s.stepTaskId === stepTaskId);
-      let prevSnapshot = null;
-      for (let i = stepIndex - 1; i >= 0; i--) {
-        if (snapshots[i].status === 'success' || snapshots[i].status === 'completed') {
-          prevSnapshot = snapshots[i];
-          break;
+
+      // Collect upstream outputs from checkpoints
+      const prevOutputs = {};
+      let prevOutput = '';
+      let prevTaskId = '';
+
+      for (const s of snapshots) {
+        if (s.stepTaskId !== stepTaskId && (s.status === 'success' || s.status === 'completed')) {
+          prevOutputs[s.stepTaskId] = String(s.output || '');
+          prevOutput = String(s.output || '');
+          prevTaskId = s.stepTaskId;
         }
       }
 
-      const prevOutput = prevSnapshot ? prevSnapshot.output : '';
-      const prevTaskId = prevSnapshot ? prevSnapshot.stepTaskId : '';
+      // Reset barrier locks for stepTaskId and downstream dependents so they can re-trigger
+      this.triggeredBarriers.delete(`${chainRunId}:${stepTaskId}`);
+      if (this.store?.tasks) {
+        for (const t of Object.values(this.store.tasks)) {
+          const deps = sanitizeDependsOn(t?.dependsOn);
+          if (deps.includes(stepTaskId)) {
+            this.triggeredBarriers.delete(`${chainRunId}:${t.id}`);
+          }
+        }
+      }
 
       // Execute only the failed step, passing reconstructed chain context
       const runFn = (scheduler.runTask || scheduler.runNow).bind(scheduler);
       const res = await runFn(stepTaskId, {
         chainRunId,
+        prevOutputs,
         chainPrevOutput: prevOutput,
+        prevOutput,
         chainPrevTaskId: prevTaskId,
+        prevTaskId,
         isRetry: true,
       });