bulltrackers-module 1.0.654 → 1.0.656

package/functions/api-v2/helpers/data-fetchers/firestore.js

@@ -1222,7 +1222,7 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
             const shardCount = pointerData._shardCount || 0;
             console.log(`[Computation] Reassembling ${shardCount} shards for ${computationName}`);
             
-            if (shardCount === 0) return []; // Or empty object
+            if (shardCount === 0) return {}; // Return empty object for object-based results
 
             // Create an array of promises to fetch all shards in parallel
             const shardPromises = [];
@@ -1233,10 +1233,9 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
 
             const shardSnaps = await Promise.all(shardPromises);
             
-            // Reassemble data. 
-            // Assuming shards contain lists of data that need concatenation.
-            // Adjust logic if shards contain maps that need merging.
-            let reassembledData = [];
+            // Reassemble data by merging objects (for object-based results like GlobalAumPerAsset30D)
+            // Shards contain partial objects that need to be merged together
+            let reassembledData = {};
             
             shardSnaps.forEach((snap, index) => {
                 if (snap.exists) {
@@ -1244,9 +1243,14 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
                     // If the shard itself is compressed (common in big data), decompress it
                     const content = (data._compressed) ? tryDecompress(data) : data;
                     
-                    // Push to master list. Assuming standard structure { items: [...] } or Array
-                    // If specific structure isn't known, we push the whole object.
-                    reassembledData.push(content);
+                    // Merge shard contents, ignoring internal metadata fields
+                    if (content && typeof content === 'object') {
+                        Object.entries(content).forEach(([k, v]) => {
+                            if (!k.startsWith('_')) {
+                                reassembledData[k] = v;
+                            }
+                        });
+                    }
                 } else {
                     console.warn(`[Computation] Missing shard_${index} for ${computationName}`);
                 }
@@ -1273,6 +1277,98 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
     }
 };
 
+// 10.4. Find most recent available GlobalAumPerAsset30D data
+// Looks back up to 7 days to find the most recent available data
+const findMostRecentGlobalAumData = async (db, startDateStr, maxLookbackDays = 7) => {
+    try {
+        const startDate = new Date(startDateStr);
+        
+        // Look back through dates to find the most recent available data
+        for (let i = 0; i < maxLookbackDays; i++) {
+            const checkDate = new Date(startDate);
+            checkDate.setDate(startDate.getDate() - i);
+            const dateKey = checkDate.toISOString().split('T')[0];
+            
+            try {
+                const computationData = await getComputationResults(db, 'GlobalAumPerAsset30D', dateKey);
+                
+                // If we got valid data (not null/empty), return it
+                if (computationData && typeof computationData === 'object' && Object.keys(computationData).length > 0) {
+                    return {
+                        date: dateKey,
+                        data: computationData
+                    };
+                }
+            } catch (error) {
+                // Missing data for this date - continue looking back
+                console.log(`[GlobalAum] No data found for ${dateKey}, checking previous date...`);
+            }
+        }
+        
+        // No data found in the lookback period
+        return null;
+    } catch (error) {
+        console.error(`[GlobalAum] Error finding most recent data:`, error);
+        throw error;
+    }
+};
+
+// 10.5. Fetch GlobalAumPerAsset30D with 7-day lookback
+// Returns the last 7 days of successfully stored data for a specific ticker or all assets
+const fetchGlobalAumPerAssetWithLookback = async (db, dateStr, ticker = null, lookbackDays = 7) => {
+    try {
+        const endDate = new Date(dateStr);
+        const results = [];
+        
+        // Fetch data for the last 7 days, handling missing data gracefully
+        for (let i = 0; i < lookbackDays; i++) {
+            const checkDate = new Date(endDate);
+            checkDate.setDate(endDate.getDate() - i);
+            const dateKey = checkDate.toISOString().split('T')[0];
+            
+            try {
+                const computationData = await getComputationResults(db, 'GlobalAumPerAsset30D', dateKey);
+                
+                // If we got valid data (not null/empty), add it to results
+                if (computationData && typeof computationData === 'object' && Object.keys(computationData).length > 0) {
+                    if (ticker) {
+                        // If searching for a specific ticker, only include if it exists
+                        const tickerUpper = ticker.toUpperCase();
+                        if (computationData[tickerUpper] !== undefined) {
+                            results.push({
+                                date: dateKey,
+                                aum: computationData[tickerUpper],
+                                ticker: tickerUpper
+                            });
+                        }
+                    } else {
+                        // Return all assets for this date
+                        results.push({
+                            date: dateKey,
+                            data: computationData
+                        });
+                    }
+                }
+            } catch (error) {
+                // Missing data for this date - skip it (graceful handling)
+                console.log(`[GlobalAum] No data found for ${dateKey}, skipping`);
+            }
+        }
+        
+        // Sort by date descending (newest first)
+        results.sort((a, b) => {
+            const dateA = new Date(a.date);
+            const dateB = new Date(b.date);
+            return dateB.getTime() - dateA.getTime();
+        });
+        
+        return results;
+    } catch (error) {
+        console.error(`[GlobalAum] Error fetching with lookback:`, error);
+        throw error;
+    }
+};
+
 // 11. Fetch User Notifications
 const fetchNotifications = async (firestore, userId, options = {}) => {
     const { limit = 20, unreadOnly = false, excludeTypes = ['watchlistAlerts'] } = options;
@@ -2913,6 +3009,9 @@ const subscribeToAllWatchlistPIs = async (db, userId, watchlistId, alertTypes =
 module.exports = {
     latestUserCentricSnapshot,
     pageCollection,
+    findMostRecentGlobalAumData,
+    fetchGlobalAumPerAssetWithLookback,
+    getComputationResults,
     fetchPopularInvestorMasterList,
     isDeveloper,
     lookupCidByEmail,

package/functions/api-v2/routes/popular_investors.js

@@ -8,10 +8,13 @@ const {
     getComputationResults, 
     requestPopularInvestorAddition,
     trackPopularInvestorView,
-    pageCollection
+    pageCollection,
+    findMostRecentGlobalAumData,
+    fetchGlobalAumPerAssetWithLookback
 } = require('../helpers/data-fetchers/firestore.js');
 const { sanitizeCid } = require('../helpers/security_utils.js');
 const { timeouts } = require('../helpers/timeout_utils.js');
+const { requireFirebaseAuth } = require('../middleware/firebase_auth_middleware.js');
 
 const router = express.Router();
 
@@ -255,5 +258,93 @@ router.get('/:piId/analytics', async (req, res) => {
     }
 });
 
+/**
+ * GLOBAL AUM PER ASSET - Public for all signed-in users
+ * 
+ * These routes show how much $ is invested in each asset based on AUM totals of all Popular Investors.
+ * - Uses GlobalAumPerAsset30D computation
+ * - Access: Public (any signed-in user can view)
+ * - Requires Firebase authentication
+ */
+
+// GET /popular-investors/global-aum - Get top assets by AUM (default: top 10)
+router.get('/global-aum', requireFirebaseAuth, async (req, res, next) => {
+    try {
+        const { db } = req.dependencies;
+        const { date, limit = 10 } = req.query;
+        
+        // Default to today if no date provided
+        const targetDate = date || new Date().toISOString().split('T')[0];
+        
+        // Find the most recent available data (looks back up to 7 days if today's data doesn't exist)
+        const result = await findMostRecentGlobalAumData(db, targetDate, 7);
+        
+        if (!result || !result.data || Object.keys(result.data).length === 0) {
+            return res.status(404).json({ 
+                success: false,
+                error: 'No AUM data available in the last 7 days' 
+            });
+        }
+        
+        // Convert to array and sort by AUM (descending)
+        const assetsArray = Object.entries(result.data)
+            .map(([ticker, aum]) => ({ ticker, aum: Number(aum) }))
+            .sort((a, b) => b.aum - a.aum)
+            .slice(0, parseInt(limit) || 10);
+        
+        res.json({ 
+            success: true, 
+            date: result.date, // Return the actual date of the data found
+            count: assetsArray.length,
+            data: assetsArray
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
+// GET /popular-investors/global-aum/:ticker - Get 7-day AUM history for a specific ticker
+router.get('/global-aum/:ticker', requireFirebaseAuth, async (req, res, next) => {
+    try {
+        const { db } = req.dependencies;
+        const { ticker } = req.params;
+        const { date, lookback = 7 } = req.query;
+        
+        // Validate ticker
+        if (!ticker || typeof ticker !== 'string' || ticker.length === 0) {
+            return res.status(400).json({ 
+                success: false,
+                error: 'Invalid ticker symbol' 
+            });
+        }
+        
+        // Default to today if no date provided
+        const targetDate = date || new Date().toISOString().split('T')[0];
+        
+        // Validate lookback parameter
+        const lookbackDays = Math.min(Math.max(parseInt(lookback) || 7, 1), 30); // Between 1 and 30 days
+        
+        // Fetch 7-day lookback data for the ticker
+        const results = await fetchGlobalAumPerAssetWithLookback(db, targetDate, ticker, lookbackDays);
+        
+        if (results.length === 0) {
+            return res.status(404).json({ 
+                success: false,
+                error: `No AUM data found for ticker ${ticker.toUpperCase()} in the last ${lookbackDays} days` 
+            });
+        }
+        
+        res.json({ 
+            success: true, 
+            ticker: ticker.toUpperCase(),
+            lookbackDays: lookbackDays,
+            count: results.length,
+            data: results
+        });
+    } catch (error) {
+        next(error);
+    }
+});
+
 
 module.exports = router;

package/package.json

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