bulltrackers-module 1.0.221 → 1.0.222

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');
@@ -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
+    // 1. Version Check: Determine which calculations are *stale*
     const dailyStatus    = await fetchComputationStatus(dateStr, config, dependencies);
     const calcsToAttempt = [];
     
@@ -77,22 +77,17 @@ 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.`); 
+            // 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; 
         }
@@ -100,7 +95,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 +107,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 Dependencies
+    const runnableCalcs = getViableCalculations(calcsToAttempt, 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.`);
+        return null;
+    }
 
     const standardToRun = runnableCalcs.filter(c => c.type === 'standard');
     const metaToRun = runnableCalcs.filter(c => c.type === 'meta');
@@ -123,6 +125,7 @@ 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

@@ -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,15 +22,60 @@ 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 (from previous passes) are present in dailyStatus.
+ * * @param {Array} candidates - Calculations attempting to run in this pass.
+ * @param {Object} rootDataStatus - { hasPortfolio: bool, hasPrices: bool... }
+ * @param {Object} dailyStatus - Map of { "calc-name": "hash" } for completed items.
+ */
+function getViableCalculations(candidates, rootDataStatus, dailyStatus) {
+    const viable = [];
+    
+    for (const calc of candidates) {
+        // 1. Check Root Data
+        const rootCheck = checkRootDependencies(calc, rootDataStatus);
+        if (!rootCheck.canRun) {
+            // Root data missing -> Impossible to run.
+            continue;
+        }
+
+        // 2. Check Dependencies
+        let dependenciesMet = true;
+        if (calc.dependencies && calc.dependencies.length > 0) {
+            for (const depName of calc.dependencies) {
+                const normDep = normalizeName(depName);
+                
+                // If a dependency is missing from dailyStatus, it failed in a previous pass.
+                // Therefore, the current calculation is impossible.
+                if (!dailyStatus[normDep]) {
+                    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;
 
     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; }));
         }
@@ -43,11 +89,12 @@ 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);
 
+        // If ABSOLUTELY NO data exists, we can return null early
         if (!(hasPortfolio || hasInsights || hasSocial || hasHistory || hasPrices)) return null;
 
         return { 
@@ -56,7 +103,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 // Filled later by StandardExecutor if needed
         };
     } catch (err) { 
         logger.log('ERROR', `Error checking data: ${err.message}`); 
@@ -64,7 +111,11 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
     }
 }
 
-async function checkPriceDataAvailability(config, { db }) { 
+/**
+ * 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';
         const snapshot = await db.collection(collection).limit(1).get(); 
@@ -72,4 +123,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.222",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [