bulltrackers-module 1.0.230 → 1.0.231

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Implements 'IMPOSSIBLE' state logic for missing root data on historical dates.
+ * UPDATED: Removed legacy boolean 'true' logic.
  */
 const { normalizeName }                                    = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -10,7 +10,6 @@ const { StandardExecutor }                                 = require('./executor
 const { MetaExecutor }                                     = require('./executors/MetaExecutor');
 const { generateProcessId, PROCESS_TYPES }                 = require('./logger/logger');
 
-// New Status Constant
 const STATUS_IMPOSSIBLE = 'IMPOSSIBLE';
 
 function groupByPass(manifest) { 
@@ -20,21 +19,14 @@ function groupByPass(manifest) {
     }, {}); 
 }
 
-/**
- * Performs strict analysis of what can run.
- * IMPOSSIBLE LOGIC:
- * 1. If Root Data is missing AND Date != Today -> IMPOSSIBLE.
- * 2. If Dependency is IMPOSSIBLE -> IMPOSSIBLE.
- * 3. IMPOSSIBLE items are written to DB to prevent future retries.
- */
 function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus, manifestMap) {
     const report = {
         runnable: [],
-        blocked: [],          // Missing Root Data (Today - Retriable)
-        impossible: [],       // Missing Root Data (Historical) or Dependency Impossible
-        failedDependency: [], // Missing/Stale Dependency (Transient)
-        reRuns: [],           // Hash Mismatch
-        skipped: []           // Already done & valid
+        blocked: [],          
+        impossible: [],       
+        failedDependency: [], 
+        reRuns: [],           
+        skipped: []           
     };
 
     const isTargetToday = (dateStr === new Date().toISOString().slice(0, 10));
@@ -44,9 +36,7 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         const storedDepHash = dailyStatus[norm];
         const depManifest = manifestMap.get(norm);
 
-        // Check 1: Is dependency IMPOSSIBLE? (Logic handled in main loop, but safe to check here)
         if (storedDepHash === STATUS_IMPOSSIBLE) return false; 
-
         if (!storedDepHash) return false; 
         if (!depManifest) return false;
         if (storedDepHash !== depManifest.hash) return false;
@@ -59,7 +49,7 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         const storedHash = dailyStatus[cName];
         const currentHash = calc.hash;
 
-        // 1. Check if ALREADY marked IMPOSSIBLE
+        // 1. Check Impossible
         if (storedHash === STATUS_IMPOSSIBLE) {
             report.skipped.push({ name: cName, reason: 'Permanently Impossible' });
             continue;
@@ -78,7 +68,6 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         }
 
         if (missingRoots.length > 0) {
-            // LOGIC: If date is NOT today, missing root data is fatal and permanent.
             if (!isTargetToday) {
                 report.impossible.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')} (Historical)` });
             } else {
@@ -95,10 +84,8 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             for (const dep of calc.dependencies) {
                 const normDep = normalizeName(dep);
                 
-                // Check if the dependency is marked IMPOSSIBLE in the DB
                 if (dailyStatus[normDep] === STATUS_IMPOSSIBLE) {
                     dependencyIsImpossible = true;
-                    // We can break early, if one input is impossible, the result is impossible.
                     break; 
                 }
 
@@ -109,7 +96,6 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         }
 
         if (dependencyIsImpossible) {
-            // Propagate the Impossible Status
             report.impossible.push({ name: cName, reason: 'Dependency is Impossible' });
             continue;
         }
@@ -119,14 +105,13 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             continue;
         }
 
-        // 4. Hash / State Check
-        if (!storedHash || storedHash === false) { // false indicates previous transient failure
+        // 4. Hash / State Check (Legacy 'true' logic removed)
+        if (!storedHash || storedHash === false) { 
             report.runnable.push(calc);
         } else if (storedHash !== currentHash) {
             report.reRuns.push({ name: cName, oldHash: storedHash, newHash: currentHash });
-        } else if (storedHash === true) {
-            report.reRuns.push({ name: cName, reason: 'Legacy Upgrade' });
         } else {
+            // Stored Hash === Current Hash
             report.skipped.push({ name: cName });
         }
     }
@@ -162,7 +147,6 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     if (logger && typeof logger.logDateAnalysis === 'function') {
         logger.logDateAnalysis(dateStr, analysisReport);
     } else {
-        // Safe fallback
         const logMsg = `[Analysis] Date: ${dateStr} | Runnable: ${analysisReport.runnable.length} | Blocked: ${analysisReport.blocked.length} | Impossible: ${analysisReport.impossible.length}`;
         if (logger && logger.info) logger.info(logMsg);
         else console.log(logMsg);
@@ -170,12 +154,8 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
 
     // 5. UPDATE STATUS FOR NON-RUNNABLE ITEMS
     const statusUpdates = {};
-
-    // A. Mark BLOCKED as 'false' (Transient Failure)
     analysisReport.blocked.forEach(item => statusUpdates[item.name] = false);
     analysisReport.failedDependency.forEach(item => statusUpdates[item.name] = false);
-
-    // B. Mark IMPOSSIBLE as 'IMPOSSIBLE' (Permanent Failure - Overwrites existing status)
     analysisReport.impossible.forEach(item => statusUpdates[item.name] = STATUS_IMPOSSIBLE);
     
     if (Object.keys(statusUpdates).length > 0) {

package/functions/computation-system/persistence/ResultCommitter.js

@@ -45,12 +45,19 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                 await commitBatchInChunks(config, deps, updates, `${name} Results`);
                 
                 // Structured Storage Log
-                logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded);
+                if (logger && logger.logStorage) {
+                    logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded);
+                }
                 
-                successUpdates[name] = calc.manifest.hash || true;
+                // Update success tracking
+                if (calc.manifest.hash) {
+                    successUpdates[name] = calc.manifest.hash;
+                }
             }
         } catch (e) {
-            logger.log('ERROR', `Commit failed for ${name}`, { processId: pid, error: e.message });
+            if (logger && logger.log) {
+                 logger.log('ERROR', `Commit failed for ${name}`, { processId: pid, error: e.message });
+            }
         }
     }
 
@@ -62,10 +69,7 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     return successUpdates;
 }
 
-// ... rest of file (calculateFirestoreBytes, prepareAutoShardedWrites) remains same ...
-// Just ensure prepareAutoShardedWrites uses the provided logger if it logs internal warnings.
 function calculateFirestoreBytes(value) {
-    // ... same as before
     if (value === null) return 1;
     if (value === undefined) return 0;
     if (typeof value === 'boolean') return 1;
@@ -79,8 +83,6 @@ function calculateFirestoreBytes(value) {
 }
 
 async function prepareAutoShardedWrites(result, docRef, logger) {
-    // ... same logic, just ensure existing logs inside here use the logger properly if needed
-    // Copied from previous logic, essentially checks size > 900KB and splits
     const SAFETY_THRESHOLD_BYTES = 1000 * 1024; 
     const OVERHEAD_ALLOWANCE     = 20 * 1024;
     const CHUNK_LIMIT            = SAFETY_THRESHOLD_BYTES - OVERHEAD_ALLOWANCE;
@@ -94,8 +96,6 @@ async function prepareAutoShardedWrites(result, docRef, logger) {
 
     if ((totalSize + docPathSize) < CHUNK_LIMIT) {  const data = { ...result, _completed: true, _sharded: false };  return [{ ref: docRef, data, options: { merge: true } }];  }
 
-    // Note: We don't log "Sharding..." here anymore because we log the structured event in commitResults
-    
     for (const [key, value] of Object.entries(result)) { 
         if (key.startsWith('_')) continue;
         const keySize   = Buffer.byteLength(key, 'utf8') + 1;         

package/package.json

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