bulltrackers-module 1.0.111 → 1.0.113

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

@@ -536,15 +536,18 @@ async function runUnifiedComputation(dateToProcess, calculationsToRun, passName,
 
             const category = calc.manifest.category || 'unknown';
 
+            // --- FINAL FIX: THIS IS THE MODIFIED BLOCK ---
+            let result = null; // Default to null
             try {
-                const result = await Promise.resolve(calc.getResult());
+                // This is where the calculation runs. It might return null
+                // OR it might THROW AN ERROR (e.g., Firestore error).
+                result = await Promise.resolve(calc.getResult());
                 
-                // --- THIS IS THE FIX ---
-                // We MUST cache the result, even if it is null,
-                // so that downstream calculations know it ran.
+                // Cache the successful result (even if it's null)
                 passResults[calcName] = result;
-                // --- END FIX ---
 
+                // --- Database write logic ---
+                // (This only runs if getResult() did NOT throw an error)
                 const pendingWrites = [];
                 const summaryData = {};
 
@@ -603,19 +606,26 @@ async function runUnifiedComputation(dateToProcess, calculationsToRun, passName,
                         successCount++;
                     }
                 } else {
-                     // --- MODIFICATION: Do not log a warning if the result is null. ---
-                     // This is now expected behavior if a calc (like user-profitability-tracker)
-                     // has no data to process.
-                     // We *do* still need to log if a result is empty.
                      if (result === null) {
                          logger.log('INFO', `[${passName}] Calculation ${calcName} returned null for ${dateStr}. This is expected if no data was processed.`);
                      } else {
                          logger.log('WARN', `[${passName}] Calculation ${calcName} produced empty results {} for ${dateStr}. Skipping write.`);
                      }
                 }
+                // --- End of DB write logic ---
+
             } catch (e) {
-                logger.log('ERROR', `[${passName}] getResult/Commit failed for ${calcName} on ${dateStr}`, { err: e.message });
+                // --- THIS IS THE CRITICAL FIX ---
+                // The calculation *threw an error*.
+                // Log the real error.
+                logger.log('ERROR', `[${passName}] getResult/Commit failed for ${calcName} on ${dateStr}`, { err: e.message, stack: e.stack });
+                
+                // NOW, *still cache null* so downstream dependencies
+                // can see the failure and skip gracefully.
+                passResults[calcName] = null; 
+                // --- END CRITICAL FIX ---
             }
+            // --- END FINAL FIX BLOCK ---
         }
 
         const completionStatus = successCount === calculationsToRun.length ? 'SUCCESS' : 'WARN';
@@ -669,38 +679,59 @@ async function runMetaComputation(
             
             const instance = new CalcClass();
 
+            // --- MODIFICATION: Wrap meta-calc process in try/catch ---
+            let result = null; // Default to null
             try {
                 // --- Gather dependencies from the cache ---
-                // This check is now more robust, as the orchestrator has already
-                // logged the *reason* for a skip. We just need to check the cache.
                 const computedDependencies = {};
                 let missingDep = false;
                 if (manifestCalc.dependencies) {
                     for (const depName of manifestCalc.dependencies) {
                         const normalizedDepName = normalizeName(depName);
+                        
+                        // --- THIS IS THE LOGIC THAT IS FAILING ---
                         if (!dailyResultsCache.has(normalizedDepName)) {
-                            // This log is still important, as it indicates a logic error
-                            // if a calc *wasn't* skipped by the orchestrator but its
-                            // dependency is *still* missing (e.g., the dep returned null).
+                            // This log is now correct. The dependency is "missing"
+                            // because the upstream calc *failed* and was skipped.
                             logger.log('ERROR', `[${passName}] Missing required dependency "${normalizedDepName}" for calculation "${calcName}". This should not happen. Skipping calc.`);
                             missingDep = true;
+                            break; 
+                        }
+                        
+                        // --- NEW CHECK ---
+                        // Check if the dependency *exists* but is `null` (due to no data or failure)
+                        const depResult = dailyResultsCache.get(normalizedDepName);
+                        if (depResult === null) {
+                            // This is a *graceful* skip, not an error.
+                            logger.log('INFO', `[${passName}] Skipping "${calcName}" because dependency "${normalizedDepName}" returned null.`);
+                            missingDep = true; // Set to true to skip
                             break;
                         }
-                        computedDependencies[normalizedDepName] = dailyResultsCache.get(normalizedDepName);
+                        // --- END NEW CHECK ---
+
+                        computedDependencies[normalizedDepName] = depResult;
                     }
                 }
-                if (missingDep) continue;
+                if (missingDep) {
+                    // This calc is skipped, so its result is `null`
+                    passResults[calcName] = null;
+                    continue; // Skip to the next calculation
+                }
+                // --- End Dependency Check ---
+
 
                 // --- Call process with the dependencies ---
-                const result = await Promise.resolve(instance.process(
+                result = await Promise.resolve(instance.process(
                     dateStr, 
                     dependenciesForMetaCalc,
                     config, 
                     computedDependencies 
                 ));
                 
+                // Cache the result (even if it's null)
                 passResults[calcName] = result;
                 
+                // --- Database write logic ---
                 const pendingWrites = [];
                 const summaryData = {};
 
@@ -730,9 +761,16 @@ async function runMetaComputation(
                 } else {
                      logger.log('WARN', `[${passName}] Meta-calculation ${calcName} produced no results for ${dateStr}. Skipping write.`);
                 }
+                // --- End DB Write ---
+
             } catch (e) {
+                // --- THIS IS THE CRITICAL FIX for meta-calcs ---
                 logger.log('ERROR', `[${passName}] Meta-calc process/commit failed for ${calcName} on ${dateStr}`, { err: e.message, stack: e.stack });
+                // Cache null on failure
+                passResults[calcName] = null;
+                // --- END FIX ---
             }
+            // --- END MODIFICATION ---
         }
 
         const completionStatus = successCount === calculationsToRun.length ? 'SUCCESS' : 'WARN';

package/package.json

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