bulltrackers-module 1.0.650 → 1.0.652

package/functions/computation-system/WorkflowOrchestrator.js

@@ -205,7 +205,7 @@ async function executeDispatchTask(dateStr, pass, targetComputation, config, dep
     const execDate = new Date(dateStr + 'T00:00:00Z');
     const updates = (calcManifest.type === 'standard') 
         ? await StandardExecutor.run(execDate, calcsToRun, `Pass ${pass}`, config, dependencies, rootData, existingResults, previousResults)
-        : await MetaExecutor.run(execDate, calcsToRun, `Pass ${pass}`, config, dependencies, existingResults, previousResults, rootData);
+        : await MetaExecutor.run(execDate, calcsToRun, `Pass ${pass}`, config, dependencies, rootData, existingResults, previousResults);
 
     return { date: dateStr, updates };
 }

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

@@ -43,12 +43,26 @@ function isDataEmpty(data) {
  * This fixes the 'fetchExistingResults is not a function' TypeError.
  */
 async function fetchExistingResults(dateStr, calcs, fullManifest, config, deps, isHistoricalContext) {
+    const { logger } = deps;
+    
+    // DEBUG: Log entry
+    logger.log('INFO', `[DependencyFetcher] 📥 fetchExistingResults called for date: ${dateStr}, calcs: ${calcs.length}, isHistorical: ${isHistoricalContext}`);
+    logger.log('INFO', `[DependencyFetcher] 📥 Calcs being processed: ${calcs.map(c => {
+        const name = c.name || c.constructor?.name || 'unknown';
+        const hasClass = !!c.class;
+        const classType = c.class ? (typeof c.class === 'function' ? 'function' : typeof c.class) : 'none';
+        return `${name} (has class: ${hasClass}, class type: ${classType})`;
+    }).join(', ')}`);
+    
     // 1. Build Manifest Lookup (Name -> Category)
     const manifestLookup = {};
     if (Array.isArray(fullManifest)) {
         fullManifest.forEach(c => {
             manifestLookup[normalizeName(c.name)] = c.category || 'analytics';
         });
+        logger.log('INFO', `[DependencyFetcher] 📥 Built manifest lookup with ${Object.keys(manifestLookup).length} entries`);
+    } else {
+        logger.log('WARN', `[DependencyFetcher] ⚠️ fullManifest is not an array: ${typeof fullManifest}`);
     }
 
     // 2. Convert Date String to Date Object
@@ -58,7 +72,13 @@ async function fetchExistingResults(dateStr, calcs, fullManifest, config, deps,
     // 3. Delegate to fetchDependencies
     // CRITICAL: For historical context (yesterday's data), allow missing dependencies
     // Historical lookbacks are optional - gaps in historical data are permissible
-    return fetchDependencies(dateObj, calcs, config, deps, manifestLookup, isHistoricalContext);
+    const result = await fetchDependencies(dateObj, calcs, config, deps, manifestLookup, isHistoricalContext);
+    
+    // DEBUG: Log result
+    const resultKeys = Object.keys(result);
+    logger.log('INFO', `[DependencyFetcher] 📤 fetchExistingResults returning ${resultKeys.length} dependencies: ${resultKeys.length > 0 ? resultKeys.join(', ') : 'NONE'}`);
+    
+    return result;
 }
 
 /**
@@ -74,11 +94,27 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {},
     const { db, logger } = deps;
     const dStr = date.toISOString().slice(0, 10);
     
+    // DEBUG: Log entry
+    logger.log('INFO', `[DependencyFetcher] 🔍 fetchDependencies called with ${calcs.length} calc(s): ${calcs.map(c => c.name || c.constructor?.name || 'unknown').join(', ')}`);
+    
     // 1. Identify unique dependencies needed
     // CHANGED: Use a Map to track { normalizedName: originalName }
     const needed = new Map();
 
     calcs.forEach(c => {
+        const calcName = c.name || c.constructor?.name || 'unknown';
+        
+        // DEBUG: Log what we're checking
+        logger.log('INFO', `[DependencyFetcher] 🔍 Processing calc: ${calcName}`);
+        logger.log('INFO', `[DependencyFetcher]   - has class: ${!!c.class}`);
+        logger.log('INFO', `[DependencyFetcher]   - class type: ${c.class ? (typeof c.class === 'function' ? 'function' : typeof c.class) : 'none'}`);
+        logger.log('INFO', `[DependencyFetcher]   - class.getDependencies: ${c.class && typeof c.class.getDependencies === 'function' ? 'YES' : 'NO'}`);
+        logger.log('INFO', `[DependencyFetcher]   - has getDependencies: ${typeof c.getDependencies === 'function' ? 'YES' : 'NO'}`);
+        logger.log('INFO', `[DependencyFetcher]   - has dependencies array: ${Array.isArray(c.dependencies) ? `YES (${c.dependencies.length} items)` : 'NO'}`);
+        if (Array.isArray(c.dependencies)) {
+            logger.log('INFO', `[DependencyFetcher]   - dependencies array: ${c.dependencies.join(', ')}`);
+        }
+        
         // [FIX] Support both .getDependencies() method and .dependencies array
         // CRITICAL: Prefer class.getDependencies() over manifest.dependencies
         // because the class method returns original case-sensitive names,
@@ -87,26 +123,37 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {},
         if (c.class && typeof c.class.getDependencies === 'function') {
             // Use the class method - returns original case-sensitive names
             reqs = c.class.getDependencies();
+            logger.log('INFO', `[DependencyFetcher] ✅ Using c.class.getDependencies() - returned: ${JSON.stringify(reqs)}`);
         } else if (typeof c.getDependencies === 'function') {
             // Fallback: direct method call (if c is the class itself)
             reqs = c.getDependencies();
+            logger.log('INFO', `[DependencyFetcher] ✅ Using c.getDependencies() - returned: ${JSON.stringify(reqs)}`);
         } else if (c.dependencies && Array.isArray(c.dependencies)) {
             // Last resort: use manifest's dependencies array (normalized)
             // This is less ideal because names are normalized, but we'll use them as-is
             reqs = c.dependencies;
+            logger.log('INFO', `[DependencyFetcher] ⚠️ Using c.dependencies array (normalized) - returned: ${JSON.stringify(reqs)}`);
+        } else {
+            logger.log('WARN', `[DependencyFetcher] ❌ No way to get dependencies for ${calcName} - all methods failed`);
         }
             
         if (Array.isArray(reqs)) {
+            logger.log('INFO', `[DependencyFetcher] ✅ Found ${reqs.length} dependencies for ${calcName}: ${reqs.join(', ')}`);
             reqs.forEach(r => {
                 // We map the normalized version to the original requested version
                 // This ensures we fetch the right file (normalized) but return it 
                 // with the casing the user code expects (original).
                 needed.set(normalizeName(r), r);
             });
+        } else {
+            logger.log('WARN', `[DependencyFetcher] ⚠️ reqs is not an array for ${calcName}: ${typeof reqs}`);
         }
     });
     
-    if (needed.size === 0) return {};
+    if (needed.size === 0) {
+        logger.log('WARN', `[DependencyFetcher] ⚠️ No dependencies needed - returning empty object`);
+        return {};
+    }
     
     const calcNames = calcs.map(c => c.name || c.constructor?.name || 'unknown').join(', ');
     logger.log('INFO', `[DependencyFetcher] Fetching ${needed.size} dependencies for computation(s): ${calcNames} (date: ${dStr})`);

package/package.json

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