bulltrackers-module 1.0.648 → 1.0.650

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

@@ -80,9 +80,21 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {},
 
     calcs.forEach(c => {
         // [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();
+        } else if (typeof c.getDependencies === 'function') {
+            // Fallback: direct method call (if c is the class itself)
+            reqs = c.getDependencies();
+        } 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;
+        }
             
         if (Array.isArray(reqs)) {
             reqs.forEach(r => {
@@ -99,6 +111,10 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {},
     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 +158,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 +175,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,
@@ -196,9 +200,53 @@ class MetaExecutor {
                 seriesData
             });
 
+            // DEBUG: Log dependency availability
+            // 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) {
+                    const keys = Object.keys(depData);
+                    logger.log('INFO', `[MetaExecutor] ✅ Dependency '${depName}' available for ${c.name}. Keys: ${keys.length} (sample: ${keys.slice(0, 5).join(', ')})`);
+                } else {
+                    logger.log('ERROR', `[MetaExecutor] ❌ Dependency '${depName}' MISSING for ${c.name} in context.computed`);
+                }
+            });
+
             try {
                 const result = await inst.process(context);
-                inst.results = { [dStr]: { global: result } };
+                
+                // DEBUG: Log result before saving
+                if (result && typeof result === 'object') {
+                    const resultKeys = Object.keys(result);
+                    logger.log('INFO', `[MetaExecutor] ✅ ${c.name} computed result. Keys: ${resultKeys.length} (sample: ${resultKeys.slice(0, 10).join(', ')})`);
+                    if (resultKeys.length === 0) {
+                        logger.log('WARN', `[MetaExecutor] ⚠️ ${c.name} returned EMPTY result object!`);
+                    }
+                } else {
+                    logger.log('WARN', `[MetaExecutor] ⚠️ ${c.name} returned non-object result: ${typeof result} - ${result}`);
+                }
+                
+                // CRITICAL FIX: Do NOT overwrite this.results - the computation already sets it correctly
+                // The computation's process() method sets this.results, and getResult() returns it
+                // We only use the return value for logging/debugging
+                // inst.results should already be set by the computation's process() method
+                if (!inst.results) {
+                    logger.log('WARN', `[MetaExecutor] ⚠️ ${c.name} did not set this.results - using return value as fallback`);
+                    inst.results = result;
+                }
+                
+                // DEBUG: Verify what getResult() will return
+                const finalResult = await inst.getResult();
+                if (finalResult && typeof finalResult === 'object') {
+                    const finalKeys = Object.keys(finalResult);
+                    logger.log('INFO', `[MetaExecutor] ✅ ${c.name} getResult() will return ${finalKeys.length} keys`);
+                } else {
+                    logger.log('WARN', `[MetaExecutor] ⚠️ ${c.name} getResult() returns: ${typeof finalResult}`);
+                }
+                
                 state[c.name] = inst;
             } catch (e) {
                 logger.log('ERROR', `Meta calc ${c.name} failed: ${e.message}`);

package/package.json

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