bulltrackers-module 1.0.221 → 1.0.223

package/functions/computation-system/WorkflowOrchestrator.js

@@ -2,7 +2,7 @@
  * @fileoverview Main Orchestrator. Coordinates the topological execution of calculations.
  */
 const { normalizeName, getExpectedDateStrings }            = require('./utils/utils');
-const { checkRootDependencies, checkRootDataAvailability } = require('./data/AvailabilityChecker');
+const { checkRootDataAvailability, getViableCalculations } = require('./data/AvailabilityChecker');
 const { fetchExistingResults }                             = require('./data/DependencyFetcher');
 const { fetchComputationStatus, updateComputationStatus }  = require('./persistence/StatusRepository');
 const { runBatchPriceComputation }                         = require('./executors/PriceBatchExecutor');
@@ -77,15 +77,7 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
         const storedStatus = dailyStatus[cName];
         const currentHash = calc.hash;
 
-        if (calc.dependencies && calc.dependencies.length > 0) { 
-            const missing = calc.dependencies.filter(depName => !dailyStatus[normalizeName(depName)]); 
-            if (missing.length > 0) { 
-                logger.log('TRACE', `[Skip] ${cName} missing deps: ${missing.join(', ')}`);  
-                continue; 
-            } 
-        }
         if (!storedStatus) { 
-            logger.log('INFO', `[Versioning] ${cName}: New run needed.`); 
             calcsToAttempt.push(calc); continue; 
         }
         if (typeof storedStatus === 'string' && currentHash && storedStatus !== currentHash) { 
@@ -100,7 +92,7 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
 
     if (!calcsToAttempt.length) return null;
 
-    // 2. Data Check
+    // 2. Data Availability Check
     const earliestDates = {
         portfolio: new Date('2025-09-25T00:00:00Z'),
         history:   new Date('2025-11-05T00:00:00Z'),
@@ -112,8 +104,15 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const rootData = await checkRootDataAvailability(dateStr, config, dependencies, earliestDates);
     if (!rootData) { logger.log('INFO', `[DateRunner] Root data missing for ${dateStr}. Skipping.`); return null; }
     
-    const runnableCalcs = calcsToAttempt.filter(c => checkRootDependencies(c, rootData.status).canRun);
-    if (!runnableCalcs.length) return null;
+    // 3. Viability Check (Smart Execution Map)
+    // 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) {
+        // logger.log('INFO', `[DateRunner] ${dateStr}: Candidates pruned due to missing deps/data/stale hashes.`);
+        return null;
+    }
 
     const standardToRun = runnableCalcs.filter(c => c.type === 'standard');
     const metaToRun = runnableCalcs.filter(c => c.type === 'meta');

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

@@ -5,8 +5,9 @@ const {
     getPortfolioPartRefs, 
     loadDailyInsights, 
     loadDailySocialPostInsights, 
-    getHistoryPartRefs 
+    getHistoryPartRefs
 } = require('../utils/data_loader');
+const { normalizeName } = require('../utils/utils');
 
 function checkRootDependencies(calcManifest, rootDataStatus) {
     const missing = [];
@@ -21,9 +22,68 @@ function checkRootDependencies(calcManifest, rootDataStatus) {
     return { canRun: missing.length === 0, missing };
 }
 
+/**
+ * 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 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, 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) {
+            continue; // Root data missing -> Impossible.
+        }
+
+        // 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 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;
+                }
+            }
+        }
+
+        if (dependenciesMet) {
+            viable.push(calc);
+        }
+    }
+
+    return viable;
+}
+
 async function checkRootDataAvailability(dateStr, config, dependencies, earliestDates) {
-    const { logger } = dependencies;
+    const { logger, db } = dependencies;
     const dateToProcess = new Date(dateStr + 'T00:00:00Z');
+    
     let portfolioRefs = [], historyRefs = [];
     let hasPortfolio = false, hasInsights = false, hasSocial = false, hasHistory = false, hasPrices = false;
     let insightsData = null, socialData = null;
@@ -43,7 +103,7 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
             tasks.push(getHistoryPartRefs(config, dependencies, dateStr).then(r => { historyRefs = r; hasHistory = !!r.length; }));
         }
         if (dateToProcess >= earliestDates.price) {   
-            tasks.push(checkPriceDataAvailability(config, dependencies).then(r => { hasPrices = r; })); 
+            tasks.push(checkPriceAvailability(config, db).then(r => { hasPrices = r; })); 
         }
 
         await Promise.all(tasks);
@@ -56,7 +116,7 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
             todayInsights: insightsData, 
             todaySocialPostInsights: socialData, 
             status: { hasPortfolio, hasInsights, hasSocial, hasHistory, hasPrices }, 
-            yesterdayPortfolioRefs: null // Filled later if needed
+            yesterdayPortfolioRefs: null 
         };
     } catch (err) { 
         logger.log('ERROR', `Error checking data: ${err.message}`); 
@@ -64,7 +124,7 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
     }
 }
 
-async function checkPriceDataAvailability(config, { db }) { 
+async function checkPriceAvailability(config, db) { 
     try { 
         const collection = config.priceCollection || 'asset_prices';
         const snapshot = await db.collection(collection).limit(1).get(); 
@@ -72,4 +132,4 @@ async function checkPriceDataAvailability(config, { db }) {
     } catch (e) { return false; } 
 }
 
-module.exports = { checkRootDependencies, checkRootDataAvailability };
+module.exports = { checkRootDependencies, checkRootDataAvailability, getViableCalculations };

package/functions/computation-system/executors/MetaExecutor.js

@@ -30,8 +30,8 @@ class MetaExecutor {
     static async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps, config, deps, loader) {
         const mappings = await loader.loadMappings();
         const { logger } = deps;
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await loader.loadInsights(dateStr) } : null;
-        const social = metadata.rootDataDependencies?.includes('social') ? { today: await loader.loadSocial(dateStr) } : null;
+        const insights   = metadata.rootDataDependencies?.includes('insights') ? { today: await loader.loadInsights(dateStr) } : null;
+        const social     = metadata.rootDataDependencies?.includes('social')   ? { today: await loader.loadSocial(dateStr)   } : null;
         
         if (metadata.rootDataDependencies?.includes('price')) {
             logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);

package/functions/computation-system/executors/PriceBatchExecutor.js

@@ -15,7 +15,7 @@ async function runBatchPriceComputation(config, deps, dateStrings, calcs, target
     
     let targetInstrumentIds = [];
     if (targetTickers && targetTickers.length > 0) {
-        const tickerToInst = mappings.tickerToInstrument || {};
+        const tickerToInst  = mappings.tickerToInstrument || {};
         targetInstrumentIds = targetTickers.map(t => tickerToInst[t]).filter(id => id);
         if (targetInstrumentIds.length === 0) { logger.log('WARN', '[BatchPrice] Target tickers provided but no IDs found. Aborting.'); return; } 
     }

package/package.json

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