bulltrackers-module 1.0.226 → 1.0.227

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Strict Dependency & Hash Cascade Logic with Explicit Failure Marking.
+ * UPDATED: Includes defensive checks for Logger compatibility.
  */
 const { normalizeName }                                    = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -31,26 +31,17 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         runnable: [],
         blocked: [],          // Missing Root Data
         failedDependency: [], // Missing Dependency OR Stale Dependency
-        reRuns: [],           // Hash Mismatch (Triggered by self code change OR upstream cascade)
+        reRuns: [],           // Hash Mismatch
         skipped: []           // Already done & valid
     };
 
-    // Helper: Is a dependency satisfied AND valid (matching hash)?
     const isDepSatisfied = (depName, dailyStatus, manifestMap) => {
         const norm = normalizeName(depName);
         const storedDepHash = dailyStatus[norm];
         const depManifest = manifestMap.get(norm);
 
-        // 1. Must exist in DB. If missing, we cannot run.
         if (!storedDepHash) return false; 
-        
-        // 2. Must exist in Manifest (Sanity check)
         if (!depManifest) return false;
-
-        // 3. STRICT: The dependency's stored hash must match its current manifest hash.
-        // If 'A' changed code, 'A' has a new hash. If we are running 'B' (Pass 2),
-        // we expect 'A' (Pass 1) to have already run and updated the DB with the NEW hash.
-        // If DB still has OLD hash, 'A' failed or didn't run. 'B' is unsafe to run.
         if (storedDepHash !== depManifest.hash) return false;
 
         return true;
@@ -61,7 +52,7 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         const storedHash = dailyStatus[cName];
         const currentHash = calc.hash;
 
-        // 1. Root Data Check (FATAL)
+        // 1. Root Data Check
         const missingRoots = [];
         if (calc.rootDataDependencies) {
             for (const dep of calc.rootDataDependencies) {
@@ -75,12 +66,10 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
         if (missingRoots.length > 0) {
             report.blocked.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')}` });
-            continue; // Cannot proceed
+            continue;
         }
 
-        // 2. Dependency Check (FATAL)
-        // Since we are in a topological pass system, all dependencies SHOULD be satisfied 
-        // by previous passes. If not, it is a fatal error for this calculation.
+        // 2. Dependency Check
         const missingDeps = [];
         if (calc.dependencies) {
             for (const dep of calc.dependencies) {
@@ -92,23 +81,17 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
         if (missingDeps.length > 0) {
             report.failedDependency.push({ name: cName, missing: missingDeps });
-            continue; // Cannot proceed
+            continue;
         }
 
         // 3. Hash / State Check
         if (!storedHash) {
-            // Case A: No result exists (or status is 'false' from previous failure) -> RUN
-            // Note: If storedHash is boolean false, !storedHash is true, so we retry.
             report.runnable.push(calc);
         } else if (storedHash !== currentHash) {
-            // Case B: Result exists, but hash mismatch -> RE-RUN
-            // This covers code changes in THIS calc, AND cascading changes from dependencies
             report.reRuns.push({ name: cName, oldHash: storedHash, newHash: currentHash });
         } else if (storedHash === true) {
-            // Case C: Legacy boolean status -> RE-RUN (Upgrade to hash)
             report.reRuns.push({ name: cName, reason: 'Legacy Upgrade' });
         } else {
-            // Case D: Result exists, Hash Matches -> SKIP
             report.skipped.push({ name: cName });
         }
     }
@@ -119,13 +102,12 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, dependencies, computationManifest) {
     const { logger } = dependencies;
     const orchestratorPid = generateProcessId(PROCESS_TYPES.ORCHESTRATOR, passToRun, dateStr);
-
     const dateToProcess = new Date(dateStr + 'T00:00:00Z');
     
     // 1. Fetch State
     const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
     
-    // 2. Check Data Availability (One shot)
+    // 2. Check Data Availability
     const earliestDates = {
         portfolio: new Date('2025-09-25T00:00:00Z'),
         history:   new Date('2025-11-05T00:00:00Z'), 
@@ -141,11 +123,17 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const manifestMap = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
     const analysisReport = analyzeDateExecution(dateStr, calcsInThisPass, rootStatus, dailyStatus, manifestMap);
     
-    // 4. LOG ANALYSIS
-    logger.logDateAnalysis(dateStr, analysisReport);
+    // 4. LOG ANALYSIS (SAFEGUARDED)
+    if (logger && typeof logger.logDateAnalysis === 'function') {
+        logger.logDateAnalysis(dateStr, analysisReport);
+    } else {
+        // Fallback if injected logger is outdated
+        const logMsg = `[Analysis] Date: ${dateStr} | Runnable: ${analysisReport.runnable.length} | Blocked: ${analysisReport.blocked.length} | ReRuns: ${analysisReport.reRuns.length}`;
+        if (logger && logger.info) logger.info(logMsg);
+        else console.log(logMsg);
+    }
 
-    // 5. MARK FAILURES (Explicitly write 'false' to DB for blocked items)
-    // This prevents UI/downstream consumers from waiting indefinitely.
+    // 5. MARK FAILURES (Write 'false' to DB for blocked items)
     const failureUpdates = {};
     analysisReport.blocked.forEach(item => failureUpdates[item.name] = false);
     analysisReport.failedDependency.forEach(item => failureUpdates[item.name] = false);
@@ -163,11 +151,12 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const finalRunList = calcsInThisPass.filter(c => calcsToRunNames.has(normalizeName(c.name)));
 
     if (!finalRunList.length) {
-        // Nothing to run (everything either skipped, blocked, or failed)
         return { date: dateStr, updates: {}, skipped: analysisReport.skipped.length };
     }
 
-    logger.log('INFO', `[Orchestrator] Executing ${finalRunList.length} calculations for ${dateStr}`, { processId: orchestratorPid });
+    if (logger && logger.log) {
+        logger.log('INFO', `[Orchestrator] Executing ${finalRunList.length} calculations for ${dateStr}`, { processId: orchestratorPid });
+    }
 
     const standardToRun = finalRunList.filter(c => c.type === 'standard');
     const metaToRun     = finalRunList.filter(c => c.type === 'meta');
@@ -177,11 +166,8 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     try {
         const calcsRunning = [...standardToRun, ...metaToRun];
         
-        // Fetch dependencies (Previous pass results)
-        // includeSelf=false: We are re-running, so we ignore our own old results.
+        // Fetch dependencies
         const existingResults = await fetchExistingResults(dateStr, calcsRunning, computationManifest, config, dependencies, false);
-        
-        // Fetch Yesterday's results (if Historical)
         const prevDate        = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr     = prevDate.toISOString().slice(0, 10);
         const previousResults = await fetchExistingResults(prevDateStr, calcsRunning, computationManifest, config, dependencies, true);
@@ -196,9 +182,11 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
         }
 
     } catch (err) {
-        // If execution CRASHES (code bug, timeout), we log and throw.
-        // Pub/Sub will retry this message. This is correct for transient errors.
-        logger.log('ERROR', `[Orchestrator] Failed execution for ${dateStr}`, { processId: orchestratorPid, error: err.message });
+        if (logger && logger.log) {
+            logger.log('ERROR', `[Orchestrator] Failed execution for ${dateStr}`, { processId: orchestratorPid, error: err.message });
+        } else {
+            console.error(`[Orchestrator] Failed execution for ${dateStr}: ${err.message}`);
+        }
         throw err; 
     }
 

package/package.json

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