bulltrackers-module 1.0.171 → 1.0.173

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

@@ -1,8 +1,6 @@
 /**
  * FIXED: computation_pass_runner.js
- * Now calculates earliest date PER CALCULATION, not per pass
- * --- MODIFIED: Passes 'existingResults' to 'runStandardComputationPass'
- * to replicate the test harness's 7-argument signature. ---
+ * V3: Fetches Previous Day's Results to enable State Persistence.
  */
 
 const { groupByPass, checkRootDataAvailability, fetchExistingResults, runStandardComputationPass, runMetaComputationPass } = require('./orchestration_helpers.js');
@@ -11,63 +9,98 @@ const PARALLEL_BATCH_SIZE = 7;
 
 async function runComputationPass(config, dependencies, computationManifest) {
     const { logger } = dependencies;
-    const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
-    if (!passToRun) return logger.log('ERROR', '[PassRunner] No pass defined. Aborting.');
+    const passToRun  = String(config.COMPUTATION_PASS_TO_RUN);
+    if (!passToRun) 
+        return logger.log('ERROR', '[PassRunner] No pass defined. Aborting.');
+    
     logger.log('INFO', `🚀 Starting PASS ${passToRun}...`);
 
-    const earliestDates = { portfolio: new Date('2025-09-25T00:00:00Z'), history:   new Date('2025-11-05T00:00:00Z'), social:    new Date('2025-10-30T00:00:00Z'), insights:  new Date('2025-08-26T00:00:00Z') };
+    const earliestDates            = { portfolio: new Date('2025-09-25T00:00:00Z'), history: new Date('2025-11-05T00:00:00Z'), social: new Date('2025-10-30T00:00:00Z'), insights: new Date('2025-08-26T00:00:00Z') };
     earliestDates.absoluteEarliest = Object.values(earliestDates).reduce((a,b) => a < b ? a : b);
-    logger.log('INFO', `Hardcoded earliest dates: ${Object.entries(earliestDates).map(([k,v]) => `${k}=${v.toISOString().slice(0,10)}`).join(', ')}`);
 
-    const passes = groupByPass(computationManifest);
+    const passes          = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
-    if (!calcsInThisPass.length) return logger.log('WARN', `[PassRunner] No calcs for Pass ${passToRun}. Exiting.`);
+
+    if (!calcsInThisPass.length) 
+        return logger.log('WARN', `[PassRunner] No calcs for Pass ${passToRun}. Exiting.`);
+    
     const calcEarliestDates = new Map();
-    for (const calc of calcsInThisPass) { const deps = calc.rootDataDependencies || []; if (!deps.length) { calcEarliestDates.set(calc.name, earliestDates.absoluteEarliest); continue; }
-    const latestDep = new Date(Math.max(...deps.map(d => earliestDates[d]?.getTime() || 0)));
-    const calcDate = calc.isHistorical ? new Date(latestDep.getTime() + 86400000) : latestDep; // +1 day if historical
-    calcEarliestDates.set(calc.name, calcDate);
-    logger.log('TRACE', `[PassRunner] ${calc.name}: earliest=${calcDate.toISOString().slice(0,10)}`); }
+
+    for (const calc of calcsInThisPass) { 
+        const deps = calc.rootDataDependencies || []; 
+
+        if (!deps.length) 
+            { calcEarliestDates.set(calc.name, earliestDates.absoluteEarliest); continue; }
+
+        const latestDep = new Date(Math.max(...deps.map(d => earliestDates[d]?.getTime() || 0)));
+        const calcDate = calc.isHistorical 
+            ? new Date(latestDep.getTime() + 86400000) 
+            : latestDep; 
+        
+            calcEarliestDates.set(calc.name, calcDate);
+    }
 
     const passEarliestDate = new Date(Math.min(...Array.from(calcEarliestDates.values()).map(d => d.getTime())));
-    logger.log('INFO', `[PassRunner] Pass ${passToRun} analysis: Total calcs=${calcsInThisPass.length}, can start from ${passEarliestDate.toISOString().slice(0,10)}`);
-    const endDateUTC = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
+    const endDateUTC       = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
     const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
-    const standardCalcs = calcsInThisPass.filter(c => c.type === 'standard');
-    const metaCalcs = calcsInThisPass.filter(c => c.type === 'meta');
-    const checkDeps = (calc, rootData, existingResults, dateToProcess) => { if (existingResults[calc.name]) return false;
-    const earliest = calcEarliestDates.get(calc.name);
-    if (earliest && dateToProcess < earliest) return false;
+    const standardCalcs    = calcsInThisPass.filter(c => c.type === 'standard');
+    const metaCalcs        = calcsInThisPass.filter(c => c.type === 'meta');
+
+    const checkDeps = (calc, rootData, existingResults, dateToProcess) => { 
+        if (existingResults[calc.name]) 
+            return false;
 
-    const missingRoot = (calc.rootDataDependencies || []).filter(dep => !rootData.status[`has${dep[0].toUpperCase() + dep.slice(1)}`]);
-    if (missingRoot.length) return false;
+        const earliest = calcEarliestDates.get(calc.name);
 
-    if (calc.type === 'meta') { const missingComputed = (calc.dependencies || []).filter(d => !existingResults[d]); if (missingComputed.length) return false; } return true; };
+        if (earliest && dateToProcess < earliest) 
+            return false;
+
+        const missingRoot = (calc.rootDataDependencies || []).filter(dep => !rootData.status[`has${dep[0].toUpperCase() + dep.slice(1)}`]);
+
+        if (missingRoot.length) 
+            return false;
+
+        if (calc.type === 'meta') 
+            { const missingComputed = (calc.dependencies || []).filter(d => !existingResults[d]);
+                 if (missingComputed.length)
+                     return false; } 
+        return true; 
+    };
 
     const processDate = async (dateStr) => {
         const dateToProcess = new Date(dateStr + 'T00:00:00Z');
         try {
             const rootData = await checkRootDataAvailability(dateStr, config, dependencies, earliestDates);
             if (!rootData) return logger.log('WARN', `[PassRunner] Skipping ${dateStr}: No root data.`);
-            const existingResults = await fetchExistingResults(dateStr, calcsInThisPass, computationManifest, config, dependencies);
+            
+            // 1. Fetch TODAY'S results (Check what is already done)
+            const existingResults = await fetchExistingResults(dateStr, calcsInThisPass, computationManifest, config, dependencies, false);
+            
+            // 2. Fetch YESTERDAY'S results (For State Persistence) We calculate T-1 date string
+            const prevDate    = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
+            const prevDateStr = prevDate.toISOString().slice(0, 10);
+
+            // We pass 'true' to includeSelf, because we need the calc's OWN history (e.g. mimetic-latency needs previous mimetic-latency)
+            const previousResults = await fetchExistingResults(prevDateStr, calcsInThisPass, computationManifest, config, dependencies, true);
+
             const standardToRun = standardCalcs.filter(c => checkDeps(c, rootData, existingResults, dateToProcess));
             const metaToRun     = metaCalcs.filter(c => checkDeps(c, rootData, existingResults, dateToProcess));
+            
             if (!standardToRun.length && !metaToRun.length) return logger.log('INFO', `[PassRunner] All calcs complete for ${dateStr}. Skipping.`);
+            
             logger.log('INFO', `[PassRunner] Running ${dateStr}: ${standardToRun.length} standard, ${metaToRun.length} meta`);
             
-            // --- THIS IS THE CHANGE ---
-            // 'existingResults' (which is the test harness's 'precomputedDependencies')
-            // is now passed to 'runStandardComputationPass'.
-            if (standardToRun.length) await runStandardComputationPass(dateToProcess, standardToRun, `Pass ${passToRun} (Standard)`, config, dependencies, rootData, existingResults);
-            // --- END CHANGE ---
-
-            if (metaToRun.length) await runMetaComputationPass(dateToProcess, metaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, rootData);
+            // Pass 'previousResults' to the runners
+            if (standardToRun.length) await runStandardComputationPass(dateToProcess, standardToRun, `Pass ${passToRun} (Standard)`, config, dependencies, rootData, existingResults, previousResults);
+            if (metaToRun.length)     await runMetaComputationPass(dateToProcess, metaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, previousResults, rootData);
+            
         } catch (err) { logger.log('ERROR', `[PassRunner] FAILED Pass ${passToRun} for ${dateStr}`, { errorMessage: err.message, stack: err.stack }); }
     };
 
-    for (let i = 0; i < allExpectedDates.length; i += PARALLEL_BATCH_SIZE) { const batch = allExpectedDates.slice(i, i + PARALLEL_BATCH_SIZE);
-    logger.log('INFO', `[PassRunner] Processing batch ${Math.floor(i / PARALLEL_BATCH_SIZE) + 1}/${Math.ceil(allExpectedDates.length / PARALLEL_BATCH_SIZE)} (Dates: ${batch[0]}...${batch[batch.length-1]})`);
-    await Promise.all(batch.map(processDate)); }
+    for (let i = 0; i < allExpectedDates.length; i += PARALLEL_BATCH_SIZE) { 
+        const batch = allExpectedDates.slice(i, i + PARALLEL_BATCH_SIZE);
+        await Promise.all(batch.map(processDate)); 
+    }
     logger.log('INFO', `[PassRunner] Pass ${passToRun} orchestration finished.`);
 }