bulltrackers-module 1.0.562 → 1.0.564

package/functions/generic-api/user-api/helpers/core/data_lookup_helpers.js

@@ -6,6 +6,7 @@
 /**
  * Find the latest available date for signed-in user portfolio data
  * Searches backwards from today up to maxDaysBack days
+ * Checks both new root data path and legacy path for compatibility
  * @param {Firestore} db - Firestore instance
  * @param {string} signedInUsersCollection - Collection name (legacy)
  * @param {string|number} userCid - User CID
@@ -13,9 +14,51 @@
  * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
  */
 async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, maxDaysBack = 30) {
-    const CANARY_BLOCK_ID = '19M';
     const today = new Date();
+    const userCidStr = String(userCid);
+    
+    // First, check the user-centric latest snapshot (fastest check)
+    try {
+        const latestRef = db.collection('SignedInUsers')
+            .doc(userCidStr)
+            .collection('portfolio')
+            .doc('latest');
+        
+        const latestDoc = await latestRef.get();
+        if (latestDoc.exists) {
+            const data = latestDoc.data();
+            if (data && data.date) {
+                return data.date; // Found in latest snapshot
+            }
+        }
+    } catch (error) {
+        // Continue to other checks if this fails
+    }
+    
+    // Second, check the new root data path: SignedInUserPortfolioData/{date}/{cid}/{cid}
+    for (let i = 0; i < maxDaysBack; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(checkDate.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        try {
+            const rootDataRef = db.collection('SignedInUserPortfolioData')
+                .doc(dateStr)
+                .collection(userCidStr)
+                .doc(userCidStr);
+            
+            const rootDataDoc = await rootDataRef.get();
+            if (rootDataDoc.exists) {
+                return dateStr; // Found data in root data collection
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
     
+    // Third, check legacy path for backward compatibility: {signedInUsersCollection}/19M/snapshots/{date}/parts
+    const CANARY_BLOCK_ID = '19M';
     for (let i = 0; i < maxDaysBack; i++) {
         const checkDate = new Date(today);
         checkDate.setDate(checkDate.getDate() - i);
@@ -33,8 +76,8 @@ async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, max
             // Check if user's CID exists in any part document
             for (const partDoc of partsSnapshot.docs) {
                 const partData = partDoc.data();
-                if (partData && partData[String(userCid)]) {
-                    return dateStr; // Found data for this date
+                if (partData && partData[userCidStr]) {
+                    return dateStr; // Found data for this date in legacy path
                 }
             }
         } catch (error) {

package/functions/generic-api/user-api/helpers/data/portfolio_helpers.js

@@ -3,9 +3,10 @@
  * Handles user portfolio data endpoints with migration support
  */
 
-const { findLatestPortfolioDate } = require('../core/data_lookup_helpers');
+const { findLatestPortfolioDate, findLatestComputationDate } = require('../core/data_lookup_helpers');
 const { checkIfUserIsPI } = require('../core/user_status_helpers');
 const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
+const { checkPiInComputationDate } = require('./computation_helpers');
 
 /**
  * GET /user/me/portfolio
@@ -119,7 +120,9 @@ async function getUserPortfolio(req, res, dependencies, config) {
 
 /**
  * GET /user/me/data-status
- * Checks if signed-in user's portfolio data has been fetched and stored.
+ * Checks if signed-in user's profile page computation is available.
+ * The profile page uses SignedInUserProfileMetrics computation, not raw portfolio/history data.
+ * If computation exists, the profile page can be rendered. If not, user should sync.
  */
 async function getUserDataStatus(req, res, dependencies, config) {
     const { db, logger } = dependencies;
@@ -130,95 +133,80 @@ async function getUserDataStatus(req, res, dependencies, config) {
     }
 
     try {
-        const { signedInUsersCollection, signedInHistoryCollection } = config;
-        const CANARY_BLOCK_ID = '19M';
-        
         const today = new Date().toISOString().split('T')[0];
         
-        logger.log('INFO', `[getUserDataStatus] Checking data for CID: ${userCid}, Date: ${today}, Collection: ${signedInUsersCollection}`);
-        
-        // Try to find latest available date for portfolio (with fallback)
-        const portfolioDate = await findLatestPortfolioDate(db, signedInUsersCollection, userCid, 30);
-        const portfolioExists = !!portfolioDate;
-        const isPortfolioFallback = portfolioDate && portfolioDate !== today;
-        
-        if (portfolioDate && isPortfolioFallback) {
-            logger.log('INFO', `[getUserDataStatus] Using fallback portfolio date ${portfolioDate} for user ${userCid} (today: ${today})`);
-        }
-        
-        // Check history data with fallback
-        let historyExists = false;
-        let historyDate = null;
-        let isHistoryFallback = false;
-        
-        const historyCollection = signedInHistoryCollection || 'signed_in_user_history';
+        logger.log('INFO', `[getUserDataStatus] Checking computation for CID: ${userCid}, Date: ${today}`);
         
-        // Check today first
-        const todayHistoryRef = db.collection(historyCollection)
-            .doc(CANARY_BLOCK_ID)
-            .collection('snapshots')
-            .doc(today)
-            .collection('parts');
-        
-        const todayHistorySnapshot = await todayHistoryRef.get();
-        
-        if (!todayHistorySnapshot.empty) {
-            for (const partDoc of todayHistorySnapshot.docs) {
-                const partData = partDoc.data();
-                if (partData && partData[String(userCid)]) {
-                    historyExists = true;
-                    historyDate = today;
-                    break;
-                }
-            }
-        }
+        // Check for dev override impersonation
+        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
         
-        // If not found today, search backwards
-        if (!historyExists) {
-            for (let i = 1; i <= 30; i++) {
-                const checkDate = new Date();
-                checkDate.setDate(checkDate.getDate() - i);
-                const dateStr = checkDate.toISOString().split('T')[0];
+        // Primary check: Does SignedInUserProfileMetrics computation exist for this user?
+        // This is what the profile page actually uses to render
+        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+        const category = 'popular-investor';
+        const computationName = 'SignedInUserProfileMetrics';
+        
+        // Find latest computation date
+        const latestComputationDate = await findLatestComputationDate(
+            db,
+            insightsCollection,
+            resultsSub,
+            compsSub,
+            category,
+            computationName,
+            effectiveCid,
+            30
+        );
+        
+        let computationAvailable = false;
+        let computationDate = null;
+        let isComputationFallback = false;
+        
+        if (latestComputationDate) {
+            // Check if this specific user exists in the computation
+            const { found } = await checkPiInComputationDate(
+                db,
+                insightsCollection,
+                resultsSub,
+                compsSub,
+                category,
+                computationName,
+                latestComputationDate,
+                String(effectiveCid),
+                logger
+            );
+            
+            if (found) {
+                computationAvailable = true;
+                computationDate = latestComputationDate;
+                isComputationFallback = latestComputationDate !== today;
                 
-                try {
-                    const historyPartsRef = db.collection(historyCollection)
-                        .doc(CANARY_BLOCK_ID)
-                        .collection('snapshots')
-                        .doc(dateStr)
-                        .collection('parts');
-                    
-                    const historyPartsSnapshot = await historyPartsRef.get();
-                    
-                    if (!historyPartsSnapshot.empty) {
-                        for (const partDoc of historyPartsSnapshot.docs) {
-                            const partData = partDoc.data();
-                            if (partData && partData[String(userCid)]) {
-                                historyExists = true;
-                                historyDate = dateStr;
-                                isHistoryFallback = true;
-                                logger.log('INFO', `[getUserDataStatus] Found history data in fallback date ${dateStr}`);
-                                break;
-                            }
-                        }
-                    }
-                    
-                    if (historyExists) break;
-                } catch (error) {
-                    continue;
+                if (isComputationFallback) {
+                    logger.log('INFO', `[getUserDataStatus] Using fallback computation date ${computationDate} for user ${userCid} (today: ${today})`);
+                } else {
+                    logger.log('INFO', `[getUserDataStatus] Found computation for user ${userCid} on today's date`);
                 }
+            } else {
+                logger.log('INFO', `[getUserDataStatus] Computation exists for date ${latestComputationDate} but user ${userCid} not found in it`);
             }
+        } else {
+            logger.log('INFO', `[getUserDataStatus] No computation found for user ${userCid} in last 30 days`);
         }
         
+        // For backward compatibility, keep portfolioAvailable and historyAvailable
+        // but they should match computationAvailable (computation is the source of truth)
         const result = {
-            portfolioAvailable: portfolioExists,
-            historyAvailable: historyExists,
-            date: portfolioDate || today,
-            portfolioDate: portfolioDate,
-            historyDate: historyDate,
-            isPortfolioFallback: isPortfolioFallback,
-            isHistoryFallback: isHistoryFallback,
+            portfolioAvailable: computationAvailable, // Profile page uses computation, not raw portfolio
+            historyAvailable: computationAvailable,  // Profile page uses computation, not raw history
+            computationAvailable: computationAvailable, // Explicit computation check
+            date: computationDate || today,
+            computationDate: computationDate,
+            isComputationFallback: isComputationFallback,
             requestedDate: today,
-            userCid: String(userCid)
+            userCid: String(userCid),
+            effectiveCid: String(effectiveCid)
         };
         
         logger.log('INFO', `[getUserDataStatus] Result for CID ${userCid}:`, result);

package/package.json

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