bulltrackers-module 1.0.649 → 1.0.651

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,31 +94,74 @@ 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
-        const reqs = (typeof c.getDependencies === 'function') 
-            ? c.getDependencies() 
-            : (c.dependencies || []);
+        // CRITICAL: Prefer class.getDependencies() over manifest.dependencies
+        // because the class method returns original case-sensitive names,
+        // while manifest.dependencies contains normalized names
+        let reqs = [];
+        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})`);
     
+    // DEBUG: Log what dependencies we're looking for
+    const depList = Array.from(needed.entries()).map(([norm, orig]) => `${orig} (normalized: ${norm})`).join(', ');
+    logger.log('INFO', `[DependencyFetcher] Dependencies requested: ${depList}`);
+    
     const results = {};
     const missingDeps = [];
     const emptyDeps = [];
@@ -142,6 +205,9 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {},
             } else {
                 // CHANGED: Store result using the ORIGINAL name so context.computed['CaseSensitive'] works
                 results[originalName] = data;
+                // DEBUG: Log successful dependency load
+                const dataKeys = Object.keys(data);
+                logger.log('INFO', `[DependencyFetcher] ✅ Stored dependency '${originalName}' in results. Keys: ${dataKeys.length} (sample: ${dataKeys.slice(0, 5).join(', ')})`);
             }
         } catch (e) {
             missingDeps.push({ name: originalName, normalizedName: normName, path, error: e.message });
@@ -156,6 +222,10 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {},
     
     await Promise.all(promises);
     
+    // DEBUG: Log what we're returning
+    const resultKeys = Object.keys(results);
+    logger.log('INFO', `[DependencyFetcher] ✅ Returning ${resultKeys.length} dependencies: ${resultKeys.join(', ')}`);
+    
     // CRITICAL: Fail if any required dependencies are missing or empty
     // EXCEPTION: For historical/lookback scenarios, missing dependencies are permissible
     if ((missingDeps.length > 0 || emptyDeps.length > 0) && !allowMissing) {

package/functions/computation-system/executors/MetaExecutor.js

@@ -177,6 +177,10 @@ class MetaExecutor {
             const inst = new c.class();
             inst.manifest = c;
             
+            // DEBUG: Log what dependencies were fetched
+            const fetchedDepKeys = Object.keys(fetchedDeps || {});
+            logger.log('INFO', `[MetaExecutor] 📦 Fetched dependencies available: ${fetchedDepKeys.length > 0 ? fetchedDepKeys.join(', ') : 'NONE'}`);
+            
             const context = ContextFactory.buildMetaContext({
                 dateStr: dStr,
                 metadata: c,
@@ -197,7 +201,10 @@ class MetaExecutor {
             });
 
             // DEBUG: Log dependency availability
-            const depNames = c.getDependencies ? c.getDependencies() : (c.dependencies || []);
+            // CRITICAL: Use class.getDependencies() to get original case-sensitive names
+            const depNames = (c.class && typeof c.class.getDependencies === 'function') 
+                ? c.class.getDependencies() 
+                : (c.getDependencies ? c.getDependencies() : (c.dependencies || []));
             depNames.forEach(depName => {
                 const depData = context.computed[depName];
                 if (depData) {

package/package.json

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