bulltrackers-module 1.0.222 → 1.0.223

package/functions/computation-system/WorkflowOrchestrator.js

@@ -68,7 +68,7 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const { logger } = dependencies;
     const dateToProcess = new Date(dateStr + 'T00:00:00Z');
     
-    // 1. Version Check: Determine which calculations are *stale*
+    // 1. Version Check
     const dailyStatus    = await fetchComputationStatus(dateStr, config, dependencies);
     const calcsToAttempt = [];
     
@@ -78,16 +78,13 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
         const currentHash = calc.hash;
 
         if (!storedStatus) { 
-            // New calculation
             calcsToAttempt.push(calc); continue; 
         }
         if (typeof storedStatus === 'string' && currentHash && storedStatus !== currentHash) { 
-            // Code changed, must re-run
             logger.log('INFO', `[Versioning] ${cName}: Code Changed.`); 
             calcsToAttempt.push(calc); continue; 
         }
         if (storedStatus === true && currentHash) { 
-            // Migrating legacy status
             logger.log('INFO', `[Versioning] ${cName}: Upgrading legacy status.`); 
             calcsToAttempt.push(calc); continue; 
         }
@@ -108,12 +105,12 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     if (!rootData) { logger.log('INFO', `[DateRunner] Root data missing for ${dateStr}. Skipping.`); return null; }
     
     // 3. Viability Check (Smart Execution Map)
-    // Filter candidates: Remove any calculation that misses Root Data OR Dependencies
-    const runnableCalcs = getViableCalculations(calcsToAttempt, rootData.status, dailyStatus);
+    // Filter candidates: Remove any calculation that misses Root Data OR Matches Stale Dependencies
+    // PASSED: computationManifest (needed for hash lookup)
+    const runnableCalcs = getViableCalculations(calcsToAttempt, computationManifest, rootData.status, dailyStatus);
 
     if (!runnableCalcs.length) {
-        // If we had candidates but they were pruned, it means they are blocked.
-        // logger.log('INFO', `[DateRunner] ${dateStr}: Candidates pruned due to missing deps/data.`);
+        // logger.log('INFO', `[DateRunner] ${dateStr}: Candidates pruned due to missing deps/data/stale hashes.`);
         return null;
     }
 
@@ -125,7 +122,6 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
 
     try {
         const calcsRunning    = [...standardToRun, ...metaToRun];
-        // Fetch dependencies for the *runnable* calculations
         const existingResults = await fetchExistingResults(dateStr, calcsRunning, computationManifest, config, dependencies, false);
         const prevDate        = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr     = prevDate.toISOString().slice(0, 10);

package/functions/computation-system/data/AvailabilityChecker.js

@@ -26,31 +26,46 @@ function checkRootDependencies(calcManifest, rootDataStatus) {
  * Filters candidates to only those that are strictly "viable" to run.
  * A calculation is Viable if:
  * 1. All required Root Data is present.
- * 2. All required Dependencies (from previous passes) are present in dailyStatus.
+ * 2. All required Dependencies are present AND their stored hash matches their current code hash.
  * * @param {Array} candidates - Calculations attempting to run in this pass.
+ * @param {Array} fullManifest - The complete manifest (to lookup dependency current hashes).
  * @param {Object} rootDataStatus - { hasPortfolio: bool, hasPrices: bool... }
  * @param {Object} dailyStatus - Map of { "calc-name": "hash" } for completed items.
  */
-function getViableCalculations(candidates, rootDataStatus, dailyStatus) {
+function getViableCalculations(candidates, fullManifest, rootDataStatus, dailyStatus) {
     const viable = [];
+    const manifestMap = new Map(fullManifest.map(c => [normalizeName(c.name), c]));
     
     for (const calc of candidates) {
         // 1. Check Root Data
         const rootCheck = checkRootDependencies(calc, rootDataStatus);
         if (!rootCheck.canRun) {
-            // Root data missing -> Impossible to run.
-            continue;
+            continue; // Root data missing -> Impossible.
         }
 
-        // 2. Check Dependencies
+        // 2. Check Dependencies (Strict Hash Verification)
         let dependenciesMet = true;
         if (calc.dependencies && calc.dependencies.length > 0) {
             for (const depName of calc.dependencies) {
                 const normDep = normalizeName(depName);
+                const storedHash = dailyStatus[normDep];
+                const depManifest = manifestMap.get(normDep);
                 
-                // If a dependency is missing from dailyStatus, it failed in a previous pass.
-                // Therefore, the current calculation is impossible.
-                if (!dailyStatus[normDep]) {
+                // If dependency is missing from manifest, we can't verify it (shouldn't happen)
+                if (!depManifest) {
+                    dependenciesMet = false;
+                    break;
+                }
+
+                // CHECK: Does the dependency exist in DB?
+                if (!storedHash) {
+                    dependenciesMet = false;
+                    break;
+                }
+
+                // CHECK: Does the stored hash match the current code hash?
+                // This prevents running on stale data if a dependency failed to update.
+                if (storedHash !== depManifest.hash) {
                     dependenciesMet = false;
                     break;
                 }
@@ -75,7 +90,6 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
 
     try {
         const tasks = [];
-        // Only check data sources if the date is after the earliest known data point
         if (dateToProcess >= earliestDates.portfolio) {
             tasks.push(getPortfolioPartRefs(config, dependencies, dateStr).then(r => { portfolioRefs = r; hasPortfolio = !!r.length; }));
         }
@@ -94,7 +108,6 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
 
         await Promise.all(tasks);
 
-        // If ABSOLUTELY NO data exists, we can return null early
         if (!(hasPortfolio || hasInsights || hasSocial || hasHistory || hasPrices)) return null;
 
         return { 
@@ -103,7 +116,7 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
             todayInsights: insightsData, 
             todaySocialPostInsights: socialData, 
             status: { hasPortfolio, hasInsights, hasSocial, hasHistory, hasPrices }, 
-            yesterdayPortfolioRefs: null // Filled later by StandardExecutor if needed
+            yesterdayPortfolioRefs: null 
         };
     } catch (err) { 
         logger.log('ERROR', `Error checking data: ${err.message}`); 
@@ -111,10 +124,6 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
     }
 }
 
-/**
- * Checks if any price data exists in the collection.
- * Note: Uses a lightweight limit(1) query.
- */
 async function checkPriceAvailability(config, db) { 
     try { 
         const collection = config.priceCollection || 'asset_prices';

package/package.json

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