bulltrackers-module 1.0.698 → 1.0.699

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

@@ -11,7 +11,13 @@ const INDEX_COLLECTION = process.env.ROOT_DATA_AVAILABILITY_COLLECTION || 'syste
 // CONFIGURATION: Dependency Mappings
 // =============================================================================
 
-// Dependencies that map directly to a single status flag
+// Global dependencies that are NOT date-specific and are always considered available.
+// These are stored at fixed paths and don't rely on daily availability index.
+const GLOBAL_DEPS = new Set([
+    'piMasterList'  // Stored at /system_state/popular_investor_master_list (global CID->username mapping)
+]);
+
+// Dependencies that map directly to a single status flag (date-specific)
 const SIMPLE_DEP_MAP = {
     rankings:     'piRankings',
     verification: 'signedInUserVerification',
@@ -21,7 +27,7 @@ const SIMPLE_DEP_MAP = {
     pageViews:    'piPageViews',
     watchlist:    'watchlistMembership',
     alerts:       'piAlertHistory',
-    piMasterList: 'piMasterList' // <--- ADD THIS LINE
+    piMasterList: 'piMasterList' // Kept for normalizeStatus compatibility, but checked via GLOBAL_DEPS
 };
 
 // Dependencies that vary based on the userType of the calculation
@@ -68,8 +74,12 @@ function checkRootDependencies(calcManifest, rootDataStatus) {
         let isAvailable = false;
         let missingKey = dep;
 
-        // 1. Resolve Status Key
-        if (SIMPLE_DEP_MAP[dep]) {
+        // 0. Check for Global Dependencies (always available, not date-specific)
+        if (GLOBAL_DEPS.has(dep)) {
+            isAvailable = true;
+        }
+        // 1. Resolve Status Key for date-specific dependencies
+        else if (SIMPLE_DEP_MAP[dep]) {
             const key = SIMPLE_DEP_MAP[dep];
             if (rootDataStatus[key]) isAvailable = true;
             else missingKey = key;

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

@@ -211,7 +211,7 @@ async function loadVariableRootData(loader, dateStr, calcs, logger) {
  */
 async function loadSeriesData(loader, dateStr, calcs, manifestLookup, config, deps) {
     const rootRequests = {};
-    const depRequests = {};
+    const depRequests = {};        // norm -> { days, originalName }
 
     // 1. Aggregate Lookback Depths
     for (const c of calcs) {
@@ -225,7 +225,10 @@ async function loadSeriesData(loader, dateStr, calcs, manifestLookup, config, de
             Object.entries(c.dependencySeries).forEach(([name, val]) => {
                 const days = typeof val === 'object' ? val.lookback : val;
                 const norm = normalizeName(name);
-                depRequests[norm] = Math.max(depRequests[norm] || 0, days);
+                // [FIX] Track BOTH normalized name (for dedup) AND original name (for Firestore lookup)
+                if (!depRequests[norm] || depRequests[norm].days < days) {
+                    depRequests[norm] = { days, originalName: name };
+                }
             });
         }
     }
@@ -250,11 +253,13 @@ async function loadSeriesData(loader, dateStr, calcs, manifestLookup, config, de
     });
 
     // 3. Fetch Dependency Series
-    const depNames = Object.keys(depRequests);
-    if (depNames.length > 0) {
-        const maxDays = Math.max(...Object.values(depRequests));
-        deps.logger.log('INFO', `[MetaExecutor] Loading up to ${maxDays}-day series for Dependencies: ${depNames.join(', ')}`);
-        seriesData.results = await fetchResultSeries(dateStr, depNames, manifestLookup, config, deps, maxDays);
+    // [FIX] Use ORIGINAL names for Firestore document lookup (case-sensitive)
+    const depEntries = Object.values(depRequests);
+    if (depEntries.length > 0) {
+        const depOriginalNames = depEntries.map(e => e.originalName);
+        const maxDays = Math.max(...depEntries.map(e => e.days));
+        deps.logger.log('INFO', `[MetaExecutor] Loading up to ${maxDays}-day series for Dependencies: ${depOriginalNames.join(', ')}`);
+        seriesData.results = await fetchResultSeries(dateStr, depOriginalNames, manifestLookup, config, deps, maxDays);
     }
 
     await Promise.all(rootPromises);

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

@@ -383,14 +383,21 @@ async function loadGlobalRoots(loader, dateStr, calcs, deps) {
 
 async function loadSeriesData(loader, dateStr, calcs, config, deps) {
     const rootReqs = {};
-    const depReqs = {};
+    const depReqs = {};  // norm -> { days, originalName }
 
     calcs.forEach(c => {
         if (c.manifest.rootDataSeries) {
             Object.entries(c.manifest.rootDataSeries).forEach(([k, v]) => rootReqs[k] = Math.max(rootReqs[k]||0, v.lookback||v));
         }
         if (c.manifest.dependencySeries) {
-            Object.entries(c.manifest.dependencySeries).forEach(([k, v]) => depReqs[normalizeName(k)] = Math.max(depReqs[normalizeName(k)]||0, v.lookback||v));
+            // [FIX] Track BOTH normalized name (for dedup) AND original name (for Firestore lookup)
+            Object.entries(c.manifest.dependencySeries).forEach(([k, v]) => {
+                const norm = normalizeName(k);
+                const days = v.lookback || v;
+                if (!depReqs[norm] || depReqs[norm].days < days) {
+                    depReqs[norm] = { days, originalName: k };
+                }
+            });
         }
     });
 
@@ -404,12 +411,15 @@ async function loadSeriesData(loader, dateStr, calcs, config, deps) {
         if (rootMap[key]) series.root[key] = (await loader.loadSeries(rootMap[key], dateStr, days)).data;
     }));
 
-    const depNames = Object.keys(depReqs);
-    if (depNames.length) {
+    // [FIX] Use ORIGINAL names for Firestore document lookup (case-sensitive)
+    const depEntries = Object.values(depReqs);
+    if (depEntries.length) {
+        const depOriginalNames = depEntries.map(e => e.originalName);
+        const maxDays = Math.max(...depEntries.map(e => e.days));
         // Construct manifest lookup on the fly for fetched names
         const allManifests = getManifest(config.productLines, config.calculationsDirectory, deps);
         const lookup = Object.fromEntries(allManifests.map(m => [normalizeName(m.name), m.category]));
-        series.results = await fetchResultSeries(dateStr, depNames, lookup, config, deps, Math.max(...Object.values(depReqs)));
+        series.results = await fetchResultSeries(dateStr, depOriginalNames, lookup, config, deps, maxDays);
     }
 
     return series;

package/functions/computation-system/legacy/AvailabilityCheckerOld.js

@@ -189,6 +189,12 @@ function checkRootDependencies(calcManifest, rootDataStatus) {
                 }
             }
         }
+        // [GLOBAL] piMasterList is always available (not date-specific)
+        // Stored at /system_state/popular_investor_master_list
+        else if (dep === 'piMasterList') {
+            isAvailable = true;
+            available.push('piMasterList');
+        }
     }
 
     // [NEW] Enforce Mandatory Roots (defined by computation)

package/package.json

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