bulltrackers-module 1.0.652 → 1.0.654

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -230,23 +230,92 @@ async function handleForceRun(config, dependencies, computationManifest, reqBody
     }
 
     // 2. Determine Target Dates
-    let targetDates = [];
+    let candidateDates = [];
     if (dateInput) {
         // Single Date Mode
-        targetDates = [dateInput];
+        candidateDates = [dateInput];
     } else {
         // All Dates Mode (Backfill)
         logger.log('INFO', `[ForceRun] No date provided. Calculating date range for ${computationName}...`);
         const earliestDates = await getEarliestDataDates(config, dependencies);
         // Calculate from system start until today
-        targetDates = getExpectedDateStrings(earliestDates.absoluteEarliest, new Date());
+        candidateDates = getExpectedDateStrings(earliestDates.absoluteEarliest, new Date());
     }
     
-    logger.log('WARN', `[ForceRun] 🚨 MANUALLY Triggering ${computationName} for ${targetDates.length} dates. Pass: ${manifestItem.pass}`);
+    logger.log('INFO', `[ForceRun] Checking ${candidateDates.length} candidate dates for runnability...`);
 
-    // 3. Construct Tasks
+    // 3. Filter to only runnable dates using analyzeDateExecution
+    const manifestMap = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
+    const calcsInPass = groupByPass(computationManifest, manifestItem.pass || "1");
+    const targetComputationNormalized = normalizeName(computationName);
+    
+    // Filter to only the target computation
+    const targetCalcs = calcsInPass.filter(c => normalizeName(c.name) === targetComputationNormalized);
+    
+    if (targetCalcs.length === 0) {
+        throw new Error(`Computation '${computationName}' not found in pass ${manifestItem.pass || "1"}`);
+    }
+    
+    const runnableDates = [];
+    const skippedDates = [];
+    
+    for (const dateStr of candidateDates) {
+        // Check root data availability
+        const rootDataStatus = await checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES);
+        
+        // Get computation status for this date
+        const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
+        
+        // Check previous day status if needed
+        let prevDailyStatus = null;
+        if (targetCalcs.some(c => c.isHistorical)) {
+            const prevDate = new Date(dateStr + 'T00:00:00Z');
+            prevDate.setUTCDate(prevDate.getUTCDate() - 1);
+            prevDailyStatus = await fetchComputationStatus(prevDate.toISOString().slice(0, 10), config, dependencies);
+        }
+        
+        // Analyze if this computation can run on this date
+        const report = analyzeDateExecution(dateStr, targetCalcs, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
+        
+        // Check if the target computation is runnable, needs re-run, or has failed dependencies
+        const isRunnable = report.runnable.some(t => normalizeName(t.name) === targetComputationNormalized);
+        const needsReRun = report.reRuns.some(t => normalizeName(t.name) === targetComputationNormalized);
+        const hasFailedDep = report.failedDependency.some(t => normalizeName(t.name) === targetComputationNormalized);
+        const isImpossible = report.impossible.some(t => normalizeName(t.name) === targetComputationNormalized);
+        const isBlocked = report.blocked.some(t => normalizeName(t.name) === targetComputationNormalized);
+        
+        if (isRunnable || needsReRun || hasFailedDep) {
+            runnableDates.push(dateStr);
+        } else if (isImpossible) {
+            skippedDates.push({ date: dateStr, reason: report.impossible.find(t => normalizeName(t.name) === targetComputationNormalized)?.reason || 'Impossible' });
+        } else if (isBlocked) {
+            skippedDates.push({ date: dateStr, reason: report.blocked.find(t => normalizeName(t.name) === targetComputationNormalized)?.reason || 'Blocked' });
+        } else {
+            skippedDates.push({ date: dateStr, reason: 'Not runnable (unknown reason)' });
+        }
+    }
+    
+    logger.log('INFO', `[ForceRun] ✅ Found ${runnableDates.length} runnable dates out of ${candidateDates.length} candidates`);
+    if (skippedDates.length > 0) {
+        logger.log('INFO', `[ForceRun] ⏭️ Skipped ${skippedDates.length} dates: ${skippedDates.slice(0, 5).map(s => `${s.date} (${s.reason})`).join(', ')}${skippedDates.length > 5 ? '...' : ''}`);
+    }
+    
+    if (runnableDates.length === 0) {
+        return {
+            status: 'NO_RUNNABLE_DATES',
+            computation: computationName,
+            mode: dateInput ? 'SINGLE_DATE' : 'ALL_DATES',
+            datesChecked: candidateDates.length,
+            datesRunnable: 0,
+            skippedReasons: skippedDates.slice(0, 10)
+        };
+    }
+    
+    logger.log('WARN', `[ForceRun] 🚨 MANUALLY Triggering ${computationName} for ${runnableDates.length} runnable dates. Pass: ${manifestItem.pass}`);
+
+    // 4. Construct Tasks (only for runnable dates)
     const dispatchId = crypto.randomUUID();
-    const tasks = targetDates.map(date => {
+    const tasks = runnableDates.map(date => {
         const traceId = crypto.randomBytes(16).toString('hex');
         const spanId = crypto.randomBytes(8).toString('hex');
         return {
@@ -288,7 +357,10 @@ async function handleForceRun(config, dependencies, computationManifest, reqBody
         status: 'FORCED',
         computation: computationName,
         mode: dateInput ? 'SINGLE_DATE' : 'ALL_DATES',
+        datesChecked: candidateDates.length,
+        datesRunnable: runnableDates.length,
         datesTriggered: dispatchedCount,
+        skippedCount: skippedDates.length,
         targetTopic: topic
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.652",
+  "version": "1.0.654",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [