bulltrackers-module 1.0.504 → 1.0.506

package/functions/generic-api/user-api/helpers/data_helpers.js

@@ -1,2752 +1,87 @@
 /**
- * @fileoverview Helpers for Data Serving (Analytics, Watchlists).
- */
-
-const { FieldValue } = require('@google-cloud/firestore');
-const zlib = require('zlib');
-
-/**
- * Helper function to decompress computation results if they are stored as compressed byte strings
- * @param {object} data - The raw Firestore document data
- * @returns {object} The decompressed JSON object or original data if not compressed
- */
-function tryDecompress(data) {
-    if (data && data._compressed === true && data.payload) {
-        try {
-            let buffer;
-            
-            // Handle different payload types from Firestore
-            if (Buffer.isBuffer(data.payload)) {
-                // Already a Buffer - use directly
-                buffer = data.payload;
-            } else if (typeof data.payload === 'string') {
-                // If it's a string, try base64 first, then direct
-                try {
-                    buffer = Buffer.from(data.payload, 'base64');
-                } catch (e) {
-                    // If not base64, might already be decompressed JSON string
-                    try {
-                        const parsed = JSON.parse(data.payload);
-                        // If parsing succeeds, return it (data was already decompressed)
-                        return parsed;
-                    } catch (e2) {
-                        // Not JSON either, try as raw buffer
-                        buffer = Buffer.from(data.payload);
-                    }
-                }
-            } else {
-                // Try to convert to Buffer
-                buffer = Buffer.from(data.payload);
-            }
-            
-            // Decompress the buffer
-            const decompressed = zlib.gunzipSync(buffer);
-            const jsonString = decompressed.toString('utf8');
-            
-            // Log first 200 chars to debug
-            console.log('[tryDecompress] Decompressed JSON string (first 200 chars):', jsonString.substring(0, 200));
-            
-            // Parse the JSON string
-            const parsed = JSON.parse(jsonString);
-            
-            // Verify it's an object, not a string
-            if (typeof parsed === 'string') {
-                console.log('[tryDecompress] WARNING: Parsed result is still a string! Attempting double parse...');
-                // Might be double-encoded JSON string
-                return JSON.parse(parsed);
-            }
-            
-            console.log('[tryDecompress] Successfully decompressed. Type:', typeof parsed, 'Keys:', typeof parsed === 'object' && !Array.isArray(parsed) ? Object.keys(parsed).slice(0, 5) : 'N/A');
-            return parsed;
-        } catch (e) {
-            console.error('[DataHelpers] Decompression failed:', e.message);
-            console.error('[DataHelpers] Error stack:', e.stack);
-            // Return empty object on failure to avoid crashing
-            return {};
-        }
-    }
-    return data;
-}
-
-/**
- * Helper function to find the latest available date for signed-in user portfolio data
- * Searches backwards from today up to 30 days
- */
-async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, maxDaysBack = 30, collectionRegistry = null) {
-    const CANARY_BLOCK_ID = '19M';
-    const today = new Date();
-    
-    // Try new structure first if collectionRegistry is available
-    if (collectionRegistry) {
-        try {
-            const { getRootDataPortfolioPath } = require('./collection_helpers');
-            
-            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 rootPath = getRootDataPortfolioPath(collectionRegistry, dateStr, userCid);
-                    const rootDoc = await db.doc(rootPath).get();
-                    
-                    if (rootDoc.exists) {
-                        const data = rootDoc.data();
-                        if (data && (data.AggregatedPositions || data.AggregatedMirrors)) {
-                            return dateStr; // Found data in new structure
-                        }
-                    }
-                } catch (error) {
-                    // Continue to next date if error
-                    continue;
-                }
-            }
-        } catch (error) {
-            // Fall through to legacy check
-        }
-    }
-    
-    // Fallback to legacy structure
-    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 partsRef = db.collection(signedInUsersCollection)
-                .doc(CANARY_BLOCK_ID)
-                .collection('snapshots')
-                .doc(dateStr)
-                .collection('parts');
-            
-            const partsSnapshot = await partsRef.get();
-            
-            // 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
-                }
-            }
-        } catch (error) {
-            // Continue to next date if error
-            continue;
-        }
-    }
-    
-    return null; // No data found in the last maxDaysBack days
-}
-
-/**
- * Helper function to find the latest available date for computation results
- * Searches backwards from today up to 30 days
- */
-async function findLatestComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, userCid, maxDaysBack = 30) {
-    const today = new Date();
-    
-    // Log the path structure being checked
-    console.log(`[findLatestComputationDate] Searching for: ${insightsCollection}/{date}/${resultsSub}/${category}/${compsSub}/${computationName}`);
-    
-    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 computationRef = db.collection(insightsCollection)
-                .doc(dateStr)
-                .collection(resultsSub)
-                .doc(category)
-                .collection(compsSub)
-                .doc(computationName);
-            
-            const computationDoc = await computationRef.get();
-            
-            // Log each date being checked
-            if (i < 3) { // Only log first 3 to avoid spam
-                console.log(`[findLatestComputationDate] Checking date ${dateStr}: exists=${computationDoc.exists}`);
-            }
-            
-            // Just check if document exists - don't check for CID here
-            // We'll check for CID in the calling function after decompression
-            if (computationDoc.exists) {
-                console.log(`[findLatestComputationDate] Found document at date: ${dateStr}`);
-                return dateStr; // Found document for this date
-            }
-        } catch (error) {
-            // Log errors for debugging
-            console.error(`[findLatestComputationDate] Error checking date ${dateStr}:`, error.message);
-            // Continue to next date if error
-            continue;
-        }
-    }
-    
-    console.log(`[findLatestComputationDate] No document found in last ${maxDaysBack} days`);
-    return null; // No document found in the last maxDaysBack days
-}
-
-/**
- * Check if a signed-in user is also a Popular Investor
- * Returns ranking entry if found, null otherwise
- * Checks dev overrides first for pretendToBePI flag
- */
-async function checkIfUserIsPI(db, userCid, config, logger = null) {
-    try {
-        // Check dev override first (for developer accounts)
-        const { getDevOverride } = require('./dev_helpers');
-        const devOverride = await getDevOverride(db, userCid, config, logger);
-        
-        if (devOverride && devOverride.enabled && devOverride.pretendToBePI) {
-            // Generate fake ranking entry for dev testing
-            const fakeRankEntry = {
-                CustomerId: Number(userCid),
-                UserName: 'Dev Test PI',
-                AUMValue: 500000 + Math.floor(Math.random() * 1000000), // Random AUM between 500k-1.5M
-                Copiers: 150 + Math.floor(Math.random() * 200), // Random copiers between 150-350
-                RiskScore: 3 + Math.floor(Math.random() * 3), // Random risk score 3-5
-                Gain: 25 + Math.floor(Math.random() * 50), // Random gain 25-75%
-                WinRatio: 50 + Math.floor(Math.random() * 20), // Random win ratio 50-70%
-                Trades: 500 + Math.floor(Math.random() * 1000) // Random trades 500-1500
-            };
-            
-            if (logger && logger.log) {
-                logger.log('INFO', `[checkIfUserIsPI] DEV OVERRIDE: User ${userCid} pretending to be PI with fake ranking data`);
-            } else {
-                console.log(`[checkIfUserIsPI] DEV OVERRIDE: User ${userCid} pretending to be PI with fake ranking data`);
-            }
-            
-            return fakeRankEntry;
-        }
-        
-        // Otherwise, check real rankings
-        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
-        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
-        
-        if (!rankingsDate) {
-            return null;
-        }
-        
-        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
-        const rankingsDoc = await rankingsRef.get();
-        
-        if (!rankingsDoc.exists) {
-            return null;
-        }
-        
-        const rankingsData = rankingsDoc.data();
-        const rankingsItems = rankingsData.Items || [];
-        
-        // Find user in rankings
-        const userRankEntry = rankingsItems.find(item => String(item.CustomerId) === String(userCid));
-        
-        return userRankEntry || null;
-    } catch (error) {
-        console.error('[checkIfUserIsPI] Error checking if user is PI:', error);
-        return null;
-    }
-}
-
-/**
- * Helper function to find the latest available date for Popular Investor rankings
- * Searches backwards from today up to 30 days
- */
-async function findLatestRankingsDate(db, rankingsCollection, maxDaysBack = 30) {
-    const today = new Date();
-    
-    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 rankingsRef = db.collection(rankingsCollection).doc(dateStr);
-            const rankingsDoc = await rankingsRef.get();
-            
-            if (rankingsDoc.exists) {
-                return dateStr; // Found rankings for this date
-            }
-        } catch (error) {
-            // Continue to next date if error
-            continue;
-        }
-    }
-    
-    return null; // No rankings found in the last maxDaysBack days
-}
-
-/**
- * Helper function to find the latest available date for Popular Investor portfolio data
- * Searches backwards from today up to 30 days
- */
-async function findLatestPiPortfolioDate(db, piPortfoliosCollection, userCid, maxDaysBack = 30) {
-    const CANARY_BLOCK_ID = '19M';
-    const today = new Date();
-    
-    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 partsRef = db.collection(piPortfoliosCollection)
-                .doc(CANARY_BLOCK_ID)
-                .collection('snapshots')
-                .doc(dateStr)
-                .collection('parts');
-            
-            const partsSnapshot = await partsRef.get();
-            
-            // 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
-                }
-            }
-        } catch (error) {
-            // Continue to next date if error
-            continue;
-        }
-    }
-    
-    return null; // No data found in the last maxDaysBack days
-}
-
-/**
- * Helper function to find the latest available date for Popular Investor history data
- * Searches backwards from today up to 30 days
- */
-async function findLatestPiHistoryDate(db, piHistoryCollection, userCid, maxDaysBack = 30) {
-    const today = new Date();
-    
-    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 historyRef = db.collection(piHistoryCollection)
-                .doc(String(userCid))
-                .collection('history')
-                .doc(dateStr);
-            
-            const historyDoc = await historyRef.get();
-            
-            if (historyDoc.exists) {
-                return dateStr; // Found history for this date
-            }
-        } catch (error) {
-            // Continue to next date if error
-            continue;
-        }
-    }
-    
-    return null; // No data found in the last maxDaysBack days
-}
-
-/**
- * GET /pi/{cid}/analytics
- * Fetches pre-computed analytics from the 'analytics_results' collection (Phase 3 Output).
- */
-async function getPiAnalytics(req, res, dependencies, config) {
-    const { db } = dependencies;
-    const { cid } = req.params;
-    const { analyticsCollection } = config; // e.g., 'analytics_results'
-
-    try {
-        // Phase 3 stores results by Date -> Calculation Name. 
-        // We likely want the LATEST available data for this user.
-        // Or, if Phase 3 updated a 'user_profiles' collection, we read that.
-        // Assuming Phase 3 "ResultCommitter" updates a dedicated 'pi_analytics_summary' for fast read.
-        
-        const docRef = db.collection(config.piAnalyticsSummaryCollection || 'pi_analytics_summary').doc(String(cid));
-        const doc = await docRef.get();
-
-        if (!doc.exists) {
-            return res.status(404).json({ error: "No analytics found for this user." });
-        }
-
-        return res.status(200).json(doc.data());
-
-    } catch (error) {
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/hedges (and /similar)
- * Returns personalized recommendations calculated in Phase 3.
- */
-async function getUserRecommendations(req, res, dependencies, config, type = 'hedges') {
-    const { db } = dependencies;
-    const { userCid } = req.query; // Passed via query or auth middleware
-    
-    if (!userCid) return res.status(400).json({ error: "Missing userCid" });
-
-    try {
-        // Recommendations are stored in signed_in_users/{cid}/recommendations/{type}
-        // or aggregated in the user doc.
-        const userDoc = await db.collection(config.signedInUsersCollection).doc(String(userCid)).get();
-        
-        if (!userDoc.exists) return res.status(404).json({ error: "User not found" });
-
-        const data = userDoc.data();
-        // Assuming structure: { recommendations: { hedges: [...], similar: [...] } }
-        const recs = data.recommendations ? data.recommendations[type] : [];
-
-        return res.status(200).json({ [type]: recs || [] });
-
-    } catch (error) {
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/data-status
- * Checks if signed-in user's portfolio data has been fetched and stored.
- * Returns status of portfolio and history data availability.
- * Falls back to latest available date if today's data doesn't exist.
- */
-async function getUserDataStatus(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query; // Passed via query or auth middleware
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-
-    try {
-        const { signedInUsersCollection, signedInHistoryCollection } = config;
-        const CANARY_BLOCK_ID = '19M';
-        
-        // Get today's date in YYYY-MM-DD format
-        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';
-        
-        // 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;
-                }
-            }
-        }
-        
-        // 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];
-                
-                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;
-                }
-            }
-        }
-        
-        const result = {
-            portfolioAvailable: portfolioExists,
-            historyAvailable: historyExists,
-            date: portfolioDate || today,
-            portfolioDate: portfolioDate,
-            historyDate: historyDate,
-            isPortfolioFallback: isPortfolioFallback,
-            isHistoryFallback: isHistoryFallback,
-            requestedDate: today,
-            userCid: String(userCid)
-        };
-        
-        logger.log('INFO', `[getUserDataStatus] Result for CID ${userCid}:`, result);
-        
-        return res.status(200).json(result);
-
-    } catch (error) {
-        logger.log('ERROR', `[getUserDataStatus] Error checking data status`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/watchlist
- * Fetches the user's watchlist
- */
-async function getWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const watchlistRef = db.collection(watchlistsCollection).doc(String(effectiveCid));
-        const watchlistDoc = await watchlistRef.get();
-        
-        if (!watchlistDoc.exists) {
-            return res.status(200).json({ watchlist: {} });
-        }
-        
-        const watchlistData = watchlistDoc.data();
-        return res.status(200).json({ 
-            watchlist: watchlistData,
-            effectiveCid: effectiveCid,
-            actualCid: Number(userCid)
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getWatchlist] Error fetching watchlist for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * POST /watchlist
- * Adds/Updates a watchlist item.
- */
-async function updateWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid, type, target, alertConfig } = req.body; 
-    // type: 'static' | 'dynamic'
-    // target: CID (if static) OR MongoQuery (if dynamic)
-    // alertConfig: { email: bool, push: bool, thresholds: {} }
-
-    if (!userCid || !type || !target) return res.status(400).json({ error: "Invalid payload" });
-
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        
-        const watchlistRef = db.collection(config.watchlistsCollection).doc(String(effectiveCid));
-        
-        // We store as an array or map in the user's watchlist doc
-        // Here using a map key for ID/Hash to allow updates
-        const entryId = type === 'static' ? `static_${target}` : `dyn_${Buffer.from(JSON.stringify(target)).toString('base64').slice(0,10)}`;
-
-        await watchlistRef.set({
-            [entryId]: {
-                type,
-                target,
-                alertConfig: alertConfig || {},
-                updatedAt: FieldValue.serverTimestamp()
-            }
-        }, { merge: true });
-
-        return res.status(200).json({ 
-            success: true, 
-            id: entryId,
-            effectiveCid: effectiveCid,
-            actualCid: Number(userCid)
-        });
-
-    } catch (error) {
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/portfolio
- * Fetches the signed-in user's portfolio data from Firestore
- * Falls back to latest available date if today's data doesn't exist
- */
-async function getUserPortfolio(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        const devOverride = await getDevOverride(db, userCid, config, logger);
-        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
-        
-        // If impersonating, check if the effective CID is a Popular Investor
-        // PIs store data in pi_portfolios_overall, not signed_in_users
-        if (isImpersonating) {
-            const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
-            if (rankEntry) {
-                // This is a PI being impersonated - they don't have signed_in_users portfolio data
-                // Return a helpful error indicating they should use the PI profile endpoint instead
-                return res.status(404).json({ 
-                    error: "Popular Investor account",
-                    message: `CID ${effectiveCid} is a Popular Investor. Use /user/me/pi-personalized-metrics or /user/pi/${effectiveCid}/profile instead.`,
-                    effectiveCid: effectiveCid,
-                    isImpersonating: true,
-                    isPopularInvestor: true,
-                    suggestedEndpoint: `/user/me/pi-personalized-metrics?userCid=${userCid}`
-                });
-            }
-        }
-        
-        const { signedInUsersCollection } = config;
-        const { collectionRegistry } = dependencies;
-        const CANARY_BLOCK_ID = '19M';
-        const today = new Date().toISOString().split('T')[0];
-        const effectiveCidStr = String(effectiveCid);
-        
-        // Use effective CID for portfolio lookup
-        const dataDate = await findLatestPortfolioDate(db, signedInUsersCollection, effectiveCid, 30, collectionRegistry);
-        
-        if (!dataDate) {
-            return res.status(404).json({ 
-                error: "Portfolio data not found for this user (checked last 30 days)",
-                effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
-            });
-        }
-        
-        const isFallback = dataDate !== today;
-        if (isFallback) {
-            logger.log('INFO', `[getUserPortfolio] Using fallback date ${dataDate} for effective CID ${effectiveCid} (today: ${today})`);
-        }
-        
-        // Try new structures first, then fallback to legacy
-        let portfolioData = null;
-        let source = 'new';
-        
-        // 1. Try user-centric latest snapshot
-        if (collectionRegistry) {
-            try {
-                const { getUserPortfolioPath, extractCollectionName: extractCollectionNameHelper } = require('./collection_helpers');
-                const latestPath = getUserPortfolioPath(collectionRegistry, effectiveCid);
-                const collectionName = extractCollectionNameHelper(latestPath);
-                
-                const latestDoc = await db.collection(collectionName)
-                    .doc(effectiveCidStr)
-                    .collection('portfolio')
-                    .doc('latest')
-                    .get();
-                
-                if (latestDoc.exists) {
-                    const data = latestDoc.data();
-                    // Data might be nested under CID or at root level
-                    portfolioData = data[effectiveCidStr] || data;
-                    if (portfolioData && (portfolioData.AggregatedPositions || portfolioData.AggregatedMirrors)) {
-                        source = 'user-centric';
-                    } else {
-                        portfolioData = null;
-                    }
-                }
-            } catch (newError) {
-                logger.log('WARN', `[getUserPortfolio] User-centric structure failed: ${newError.message}`);
-            }
-        }
-        
-        // 2. Try root data structure (date-based)
-        if (!portfolioData && collectionRegistry) {
-            try {
-                const { getRootDataPortfolioPath } = require('./collection_helpers');
-                const rootPath = getRootDataPortfolioPath(collectionRegistry, dataDate, effectiveCid);
-                
-                // Path is: SignedInUserPortfolioData/{date}/{cid}
-                // This is a document path, so use db.doc() directly
-                const rootDoc = await db.doc(rootPath).get();
-                
-                if (rootDoc.exists) {
-                    const data = rootDoc.data();
-                    portfolioData = data[effectiveCidStr] || data;
-                    if (portfolioData && (portfolioData.AggregatedPositions || portfolioData.AggregatedMirrors)) {
-                        source = 'root-data';
-                    } else {
-                        portfolioData = null;
-                    }
-                }
-            } catch (rootError) {
-                logger.log('WARN', `[getUserPortfolio] Root data structure failed: ${rootError.message}`);
-            }
-        }
-        
-        // 3. Fallback to legacy structure
-        if (!portfolioData) {
-            source = 'legacy';
-            const partsRef = db.collection(signedInUsersCollection)
-                .doc(CANARY_BLOCK_ID)
-                .collection('snapshots')
-                .doc(dataDate)
-                .collection('parts');
-            
-            const partsSnapshot = await partsRef.get();
-            
-            // Search through all parts to find the user's portfolio (use effective CID)
-            for (const partDoc of partsSnapshot.docs) {
-                const partData = partDoc.data();
-                if (partData && partData[effectiveCidStr]) {
-                    portfolioData = partData[effectiveCidStr];
-                    break;
-                }
-            }
-        }
-        
-        if (!portfolioData) {
-            return res.status(404).json({ 
-                error: "Portfolio data not found in any structure",
-                effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false,
-                checkedStructures: ['user-centric', 'root-data', 'legacy']
-            });
-        }
-        
-        // Apply dev override to AggregatedMirrors if dev override is active
-        // Note: devOverride is already available from earlier in the function (line 573)
-        if (devOverride && devOverride.enabled && devOverride.fakeCopiedPIs.length > 0 && portfolioData.AggregatedMirrors) {
-            logger.log('INFO', `[getUserPortfolio] Applying DEV OVERRIDE to AggregatedMirrors for user ${userCid}`);
-            
-            // Replace AggregatedMirrors with fake ones from dev override
-            portfolioData.AggregatedMirrors = devOverride.fakeCopiedPIs.map(cid => ({
-                ParentCID: Number(cid),
-                ParentUsername: `PI-${cid}`, // Placeholder, will be resolved if needed
-                Invested: 0,
-                NetProfit: 0,
-                Value: 0,
-                PendingForClosure: false
-            }));
-        }
-        
-        return res.status(200).json({
-            portfolio: portfolioData,
-            date: dataDate,
-            isFallback: isFallback,
-            requestedDate: today,
-            userCid: String(userCid),
-            devOverrideActive: devOverride && devOverride.enabled,
-            source // Indicate which structure was used
-        });
-
-    } catch (error) {
-        logger.log('ERROR', `[getUserPortfolio] Error fetching portfolio for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/social-posts
- * Fetches the signed-in user's social posts
- */
-async function getUserSocialPosts(req, res, dependencies, config) {
-    const { db, logger, collectionRegistry } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-
-    try {
-        const { getUserSocialPostsPath, extractCollectionName } = require('./collection_helpers');
-        
-        // Try new user-centric structure first
-        let posts = [];
-        let source = 'new';
-        
-        try {
-            const newPath = getUserSocialPostsPath(collectionRegistry, userCid);
-            const collectionName = extractCollectionName(newPath);
-            const cid = String(userCid);
-            
-            // Path is: signedInUsers/{cid}/posts
-            const postsRef = db.collection(collectionName)
-                .doc(cid)
-                .collection('posts');
-            
-            const postsSnapshot = await postsRef
-                .orderBy('fetchedAt', 'desc')
-                .limit(50)
-                .get();
-            
-            if (!postsSnapshot.empty) {
-                postsSnapshot.forEach(doc => {
-                    posts.push({
-                        id: doc.id,
-                        ...doc.data()
-                    });
-                });
-            }
-        } catch (newError) {
-            logger.log('WARN', `[getUserSocialPosts] New structure failed, trying legacy: ${newError.message}`);
-        }
-        
-        // Fallback to legacy structure if new structure returned no posts
-        if (posts.length === 0) {
-            source = 'legacy';
-            const { signedInSocialCollection } = config;
-            const socialCollection = signedInSocialCollection || 'signed_in_users_social';
-            
-            const postsRef = db.collection(socialCollection)
-                .doc(String(userCid))
-                .collection('posts');
-            
-            const postsSnapshot = await postsRef
-                .orderBy('createdAt', 'desc')
-                .limit(50)
-                .get();
-            
-            postsSnapshot.forEach(doc => {
-                posts.push({
-                    id: doc.id,
-                    ...doc.data()
-                });
-            });
-        }
-        
-        return res.status(200).json({
-            posts,
-            count: posts.length,
-            userCid: String(userCid),
-            source // Indicate which structure was used
-        });
-
-    } catch (error) {
-        logger.log('ERROR', `[getUserSocialPosts] Error fetching social posts for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/instrument-mappings
- * Fetches instrument ID to ticker and sector mappings for the frontend
- */
-async function getInstrumentMappings(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-
-    try {
-        // Fetch from Firestore (same source as computation system)
-        const [tickerToIdDoc, tickerToSectorDoc] = await Promise.all([
-            db.collection('instrument_mappings').doc('etoro_to_ticker').get(),
-            db.collection('instrument_sector_mappings').doc('sector_mappings').get()
-        ]);
-        
-        if (!tickerToIdDoc.exists) {
-            return res.status(404).json({ error: "Instrument mappings not found" });
-        }
-        
-        const tickerToId = tickerToIdDoc.data();
-        const tickerToSector = tickerToSectorDoc.exists ? tickerToSectorDoc.data() : {};
-        
-        // Convert to ID -> Ticker mapping (reverse the mapping)
-        const idToTicker = {};
-        const idToSector = {};
-        
-        for (const [id, ticker] of Object.entries(tickerToId)) {
-            idToTicker[String(id)] = ticker;
-            // Map ID -> Sector via ticker
-            if (tickerToSector[ticker]) {
-                idToSector[String(id)] = tickerToSector[ticker];
-            }
-        }
-        
-        return res.status(200).json({
-            instrumentToTicker: idToTicker,
-            instrumentToSector: idToSector,
-            count: Object.keys(idToTicker).length,
-            sectorCount: Object.keys(idToSector).length
-        });
-
-    } catch (error) {
-        logger.log('ERROR', `[getInstrumentMappings] Error fetching mappings`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/verification
- * Fetches the signed-in user's verification data (includes avatar URL)
- */
-async function getUserVerification(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        const devOverride = await getDevOverride(db, userCid, config, logger);
-        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
-        
-        const { signedInUsersCollection } = config;
-        
-        // If impersonating a PI, try to get username from rankings
-        if (isImpersonating) {
-            const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
-            if (rankEntry) {
-                // This is a PI - get username from rankings
-                return res.status(200).json({
-                    avatar: null, // PIs don't have avatars in our system
-                    username: rankEntry.UserName || null,
-                    fullName: null,
-                    cid: effectiveCid,
-                    verifiedAt: null,
-                    isImpersonating: true,
-                    effectiveCid: effectiveCid,
-                    actualCid: Number(userCid)
-                });
-            }
-        }
-        
-        // Fetch verification data from signed_in_users/{effectiveCid}
-        const userDocRef = db.collection(signedInUsersCollection).doc(String(effectiveCid));
-        const userDoc = await userDocRef.get();
-        
-        if (!userDoc.exists) {
-            return res.status(404).json({ error: "User verification data not found" });
-        }
-        
-        const data = userDoc.data();
-        
-        return res.status(200).json({
-            avatar: data.avatar || null,
-            username: data.username || null,
-            fullName: data.fullName || null,
-            cid: data.cid || Number(effectiveCid),
-            verifiedAt: data.verifiedAt || null,
-            isImpersonating: isImpersonating || false,
-            effectiveCid: effectiveCid,
-            actualCid: Number(userCid)
-        });
-
-    } catch (error) {
-        logger.log('ERROR', `[getUserVerification] Error fetching verification for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/computations
- * Fetches computation results for a specific signed-in user
- * Supports filtering by computation name and date range
- * Falls back to latest available date if today's data doesn't exist
- */
-async function getUserComputations(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid, computation, mode = 'latest', limit = 30 } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        const devOverride = await getDevOverride(db, userCid, config, logger);
-        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
-        
-        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-        const resultsSub = config.resultsSubcollection || 'results';
-        const compsSub = config.computationsSubcollection || 'computations';
-        
-        // NOTE: ResultCommitter ignores category metadata if computation is in a non-core folder
-        // SignedInUserProfileMetrics is in popular-investor folder, so it's stored in popular-investor category
-        // For signed-in users, computations are stored in the 'popular-investor' category (not 'signed_in_user')
-        const category = 'popular-investor';
-        const today = new Date().toISOString().split('T')[0];
-        
-        const computationNames = computation ? computation.split(',') : [];
-        
-        // If no specific computation requested, we'll need to know which ones to fetch
-        // For now, let's support specific computation requests
-        if (computationNames.length === 0) {
-            return res.status(400).json({ error: "Please specify at least one computation name" });
-        }
-        
-        // Check for dev override (for developer accounts) - use actual userCid for override check
-        const isDevOverrideActive = devOverride && devOverride.enabled && devOverride.fakeCopiedPIs.length > 0;
-        
-        let datesToCheck = [today];
-        
-        // If mode is 'latest', try to find the latest available date for the first computation
-        // Use effectiveCid for computation lookup
-        // CRITICAL: Only look back 7 days as per requirements
-        if (mode === 'latest') {
-            const firstCompName = computationNames[0];
-            const latestDate = await findLatestComputationDate(
-                db, 
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category, 
-                firstCompName, 
-                effectiveCid, 
-                7 // Only look back 7 days as per requirements
-            );
-            
-            if (latestDate) {
-                datesToCheck = [latestDate];
-                if (latestDate !== today) {
-                    logger.log('INFO', `[getUserComputations] Using fallback date ${latestDate} for effective CID ${effectiveCid} (today: ${today})`);
-                }
-            } else {
-                // No data found after 7 days - return empty (frontend will use fallback)
-                logger.log('WARN', `[getUserComputations] No computation data found for CID ${effectiveCid} in last 7 days. Frontend will use fallback.`);
-                return res.status(200).json({
-                    status: 'success',
-                    userCid: String(effectiveCid),
-                    mode,
-                    computations: computationNames,
-                    data: {},
-                    isFallback: true, // Mark as fallback since no data found
-                    requestedDate: today,
-                    isImpersonating: isImpersonating || false,
-                    actualCid: Number(userCid)
-                });
-            }
-        } else if (mode === 'series') {
-            // For series mode, get multiple dates
-            const limitNum = parseInt(limit) || 30;
-            datesToCheck = [];
-            for (let i = 0; i < limitNum; i++) {
-                const date = new Date();
-                date.setDate(date.getDate() - i);
-                datesToCheck.push(date.toISOString().split('T')[0]);
-            }
-        }
-        
-        const results = {};
-        let isFallback = false;
-        
-        // Fetch computation results for each date
-        for (const date of datesToCheck) {
-            results[date] = {};
-            
-            for (const compName of computationNames) {
-                try {
-                    const docRef = db.collection(insightsCollection)
-                        .doc(date)
-                        .collection(resultsSub)
-                        .doc(category)
-                        .collection(compsSub)
-                        .doc(compName);
-                    
-                    const doc = await docRef.get();
-                    
-                    if (doc.exists) {
-                        // Decompress if needed (handles byte string storage)
-                        const rawData = doc.data();
-                        let data = tryDecompress(rawData);
-                        
-                        // Handle string decompression result
-                        if (typeof data === 'string') {
-                            try {
-                                data = JSON.parse(data);
-                            } catch (e) {
-                                logger.log('WARN', `[getUserComputations] Failed to parse decompressed string for ${compName} on ${date}:`, e.message);
-                                data = null;
-                            }
-                        }
-                        
-                        // Check if data is sharded
-                        if (data && data._sharded === true && data._shardCount) {
-                            // Data is stored in shards - read all shards and merge
-                            const shardsCol = docRef.collection('_shards');
-                            const shardsSnapshot = await shardsCol.get();
-                            
-                            if (!shardsSnapshot.empty) {
-                                data = {};
-                                for (const shardDoc of shardsSnapshot.docs) {
-                                    const shardData = shardDoc.data();
-                                    Object.assign(data, shardData);
-                                }
-                            } else {
-                                data = null; // Sharded but no shards found
-                            }
-                        }
-                        
-                        // Filter by user CID - computation results are stored as { cid: result }
-                        // Use effectiveCid for lookup
-                        let userResult = data && typeof data === 'object' ? data[String(effectiveCid)] : null;
-                        
-                        // Apply dev override for computations that include copied PIs (use actual userCid for override check)
-                        if (isDevOverrideActive && (compName === 'SignedInUserProfileMetrics' || compName === 'SignedInUserCopiedPIs')) {
-                            if (compName === 'SignedInUserCopiedPIs') {
-                                // Override the copied PIs list
-                                userResult = {
-                                    current: devOverride.fakeCopiedPIs,
-                                    past: [],
-                                    all: devOverride.fakeCopiedPIs
-                                };
-                                logger.log('INFO', `[getUserComputations] Applied DEV OVERRIDE to SignedInUserCopiedPIs for user ${userCid}`);
-                            } else if (compName === 'SignedInUserProfileMetrics' && userResult && userResult.copiedPIs) {
-                                // Override the copiedPIs data in SignedInUserProfileMetrics
-                                // We need to construct fake mirror data from the dev override PIs
-                                const fakeMirrors = devOverride.fakeCopiedPIs.map(cid => ({
-                                    cid: Number(cid),
-                                    username: `PI-${cid}`, // Placeholder, will be resolved from rankings if available
-                                    invested: 0,
-                                    netProfit: 0,
-                                    value: 0,
-                                    pendingClosure: false,
-                                    isRanked: false
-                                }));
-                                
-                                userResult = {
-                                    ...userResult,
-                                    copiedPIs: {
-                                        chartType: 'cards',
-                                        data: fakeMirrors
-                                    }
-                                };
-                                logger.log('INFO', `[getUserComputations] Applied DEV OVERRIDE to SignedInUserProfileMetrics.copiedPIs for user ${userCid}`);
-                            }
-                        }
-                        
-                        if (userResult) {
-                            results[date][compName] = userResult;
-                        }
-                    }
-                } catch (err) {
-                    logger.log('WARN', `[getUserComputations] Error fetching ${compName} for ${date}`, err);
-                }
-            }
-            
-            // If mode is 'latest' and we found data, break early
-            if (mode === 'latest' && Object.keys(results[date]).length > 0) {
-                isFallback = date !== today;
-                break;
-            }
-        }
-        
-        // Clean up empty dates
-        const cleanedResults = {};
-        for (const [date, data] of Object.entries(results)) {
-            if (Object.keys(data).length > 0) {
-                cleanedResults[date] = data;
-            }
-        }
-        
-        return res.status(200).json({
-            status: 'success',
-            userCid: String(effectiveCid),
-            mode,
-            computations: computationNames,
-            data: cleanedResults,
-            isFallback: isFallback,
-            requestedDate: today,
-            devOverrideActive: isDevOverrideActive,
-            isImpersonating: isImpersonating || false,
-            actualCid: Number(userCid)
-        });
-
-    } catch (error) {
-        logger.log('ERROR', `[getUserComputations] Error fetching computations for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * POST /user/me/watchlist/auto-generate
- * Auto-generates watchlist based on copied PIs
- * Primary: Uses SignedInUserCopiedPIs computation (cheaper/faster)
- * Fallback: Reads portfolio AggregatedMirrors directly if computation not available
- */
-async function autoGenerateWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.body;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    try {
-        // Check for dev override impersonation (for computation lookup)
-        const { getEffectiveCid, getCopiedPIsWithDevOverride } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        
-        let copiedPIs = [];
-        let dataSource = 'unknown';
-        let isDevOverride = false;
-        const today = new Date().toISOString().split('T')[0];
-        
-        // === DEV OVERRIDE CHECK (for developer accounts) ===
-        // Note: Use actual userCid for dev override check (dev override is about what PIs the developer "copies")
-        const devResult = await getCopiedPIsWithDevOverride(db, userCid, config, logger);
-        if (devResult.isDevOverride) {
-            copiedPIs = devResult.copiedPIs;
-            dataSource = devResult.dataSource;
-            isDevOverride = true;
-            logger.log('INFO', `[autoGenerateWatchlist] Using DEV OVERRIDE for user ${userCid}, found ${copiedPIs.length} fake copied PIs`);
-        }
-        
-        // === PRIMARY: Try to fetch from computation (cheaper/faster) ===
-        // Only if dev override is not active
-        // Use effectiveCid for computation lookup (to support impersonation)
-        if (!isDevOverride) {
-            const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-            const category = 'signed_in_user';
-            const computationName = 'SignedInUserCopiedPIs';
-            
-            // Try to find latest computation date (with fallback)
-            // Use effectiveCid for lookup (supports impersonation)
-            const resultsSub = config.resultsSubcollection || 'results';
-            const compsSub = config.computationsSubcollection || 'computations';
-            const computationDate = await findLatestComputationDate(
-                db, 
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category, 
-                computationName, 
-                effectiveCid, 
-                30
-            );
-            
-            if (computationDate) {
-                const computationRef = db.collection(insightsCollection)
-                    .doc(computationDate)
-                    .collection('results')
-                    .doc(category)
-                    .collection('computations')
-                    .doc(computationName);
-                
-                const computationDoc = await computationRef.get();
-                
-                if (computationDoc.exists) {
-                    const computationData = computationDoc.data();
-                    // Use effectiveCid for lookup
-                    const userResult = computationData[String(effectiveCid)];
-                    
-                    if (userResult && userResult.current && userResult.current.length > 0) {
-                        // Convert computation result to our format
-                        copiedPIs = userResult.current.map(cid => ({
-                            cid: Number(cid),
-                            username: 'Unknown' // Username not in computation, will get from rankings
-                        }));
-                        dataSource = 'computation';
-                        logger.log('INFO', `[autoGenerateWatchlist] Using computation data (date: ${computationDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
-                    }
-                }
-            }
-        }
-        
-        // === FALLBACK: Read portfolio data directly if computation not available ===
-        // Only if dev override is not active and no computation data found
-        if (!isDevOverride && copiedPIs.length === 0) {
-            logger.log('INFO', `[autoGenerateWatchlist] Computation not available, falling back to direct portfolio read for user ${userCid}`);
-            
-            const { signedInUsersCollection } = config;
-            const CANARY_BLOCK_ID = '19M';
-            
-            // Find latest available portfolio date (with fallback)
-            const portfolioDate = await findLatestPortfolioDate(db, signedInUsersCollection, userCid, 30);
-            
-            if (!portfolioDate) {
-                logger.log('INFO', `[autoGenerateWatchlist] No portfolio data found for ${userCid} (checked last 30 days)`);
-                return res.status(200).json({ 
-                    success: true, 
-                    generated: 0, 
-                    totalCopied: 0,
-                    dataSource: 'none',
-                    message: "No portfolio data found for this user" 
-                });
-            }
-            
-            if (portfolioDate !== today) {
-                logger.log('INFO', `[autoGenerateWatchlist] Using fallback portfolio date ${portfolioDate} for user ${userCid} (today: ${today})`);
-            }
-            
-            // Fetch portfolio from signed_in_users/19M/snapshots/{date}/parts/part_X
-            const partsRef = db.collection(signedInUsersCollection)
-                .doc(CANARY_BLOCK_ID)
-                .collection('snapshots')
-                .doc(portfolioDate)
-                .collection('parts');
-            
-            const partsSnapshot = await partsRef.get();
-            
-            let portfolioData = null;
-            
-            // Search through all parts to find the user's portfolio
-            for (const partDoc of partsSnapshot.docs) {
-                const partData = partDoc.data();
-                if (partData && partData[String(userCid)]) {
-                    portfolioData = partData[String(userCid)];
-                    break;
-                }
-            }
-            
-            if (!portfolioData) {
-                logger.log('WARN', `[autoGenerateWatchlist] Portfolio data not found in parts for ${userCid}`);
-                return res.status(200).json({ 
-                    success: true, 
-                    generated: 0, 
-                    totalCopied: 0,
-                    dataSource: 'none',
-                    message: "Portfolio data not found" 
-                });
-            }
-            
-            // Extract copied PIs from AggregatedMirrors
-            const aggregatedMirrors = portfolioData.AggregatedMirrors || [];
-            
-            for (const mirror of aggregatedMirrors) {
-                const parentCID = mirror.ParentCID;
-                if (parentCID && parentCID > 0) {
-                    copiedPIs.push({
-                        cid: parentCID,
-                        username: mirror.ParentUsername || 'Unknown'
-                    });
-                }
-            }
-            
-            dataSource = 'portfolio';
-            logger.log('INFO', `[autoGenerateWatchlist] Using portfolio data (date: ${portfolioDate}) for user ${userCid}, found ${copiedPIs.length} copied PIs`);
-        }
-        
-        if (copiedPIs.length === 0) {
-            logger.log('INFO', `[autoGenerateWatchlist] No copied PIs found for user ${userCid} (source: ${dataSource})`);
-            return res.status(200).json({ 
-                success: true, 
-                generated: 0, 
-                totalCopied: 0,
-                dataSource: dataSource,
-                message: "User is not currently copying any PIs" 
-            });
-        }
-        
-        logger.log('INFO', `[autoGenerateWatchlist] Found ${copiedPIs.length} copied PIs for user ${userCid} (source: ${dataSource}): ${copiedPIs.map(p => `${p.username} (${p.cid})`).join(', ')}`);
-        
-        // 2. Fetch latest rankings data (with fallback to latest available date)
-        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
-        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
-        
-        if (!rankingsDate) {
-            logger.log('WARN', `[autoGenerateWatchlist] No rankings data found (checked last 30 days)`);
-            return res.status(404).json({ error: "Rankings data not available" });
-        }
-        
-        if (rankingsDate !== today) {
-            logger.log('INFO', `[autoGenerateWatchlist] Using fallback rankings date ${rankingsDate} (today: ${today})`);
-        }
-        
-        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
-        const rankingsDoc = await rankingsRef.get();
-        
-        if (!rankingsDoc.exists) {
-            logger.log('WARN', `[autoGenerateWatchlist] Rankings doc does not exist for ${rankingsDate}`);
-            return res.status(404).json({ error: "Rankings data not available" });
-        }
-        
-        const rankingsData = rankingsDoc.data();
-        const rankingsItems = rankingsData.Items || [];
-        
-        // Create a map of CID -> ranking entry for quick lookup
-        const rankingsMap = new Map();
-        for (const item of rankingsItems) {
-            if (item.CustomerId) {
-                rankingsMap.set(String(item.CustomerId), item);
-            }
-        }
-        
-        // 3. Create watchlist items from copied PIs
-        // Include ALL copied PIs, even if not in rankings (user is copying them, so they should be watched)
-        let matchedCount = 0;
-        const watchlistItems = [];
-        
-        for (const copiedPI of copiedPIs) {
-            const cidStr = String(copiedPI.cid);
-            const rankEntry = rankingsMap.get(cidStr);
-            
-            // Use ranking data if available, otherwise use data from portfolio/computation
-            const username = rankEntry?.UserName || copiedPI.username || 'Unknown';
-            
-            if (rankEntry) {
-                matchedCount++;
-            } else {
-                logger.log('INFO', `[autoGenerateWatchlist] Copied PI ${copiedPI.username} (${cidStr}) not found in rankings, but including in watchlist anyway`);
-            }
-            
-            watchlistItems.push({
-                cid: Number(cidStr),
-                username: username,
-                addedAt: new Date(), // Use regular Date (FieldValue.serverTimestamp() not allowed in arrays)
-                alertConfig: {
-                    newPositions: true,
-                    volatilityChanges: true,
-                    increasedRisk: true,
-                    newSector: true,
-                    increasedPositionSize: true,
-                    newSocialPost: true
-                }
-            });
-        }
-        
-        if (watchlistItems.length === 0) {
-            logger.log('INFO', `[autoGenerateWatchlist] No PIs matched in rankings for user ${userCid}`);
-            return res.status(200).json({
-                success: true,
-                generated: 0,
-                totalCopied: copiedPIs.length,
-                matchedInRankings: 0,
-                dataSource: dataSource,
-                message: "No copied PIs found in rankings"
-            });
-        }
-        
-        // 4. Create or update the auto-generated watchlist using new structure
-        // The auto-generated watchlist should always reflect the CURRENT state of copied PIs
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const userWatchlistsRef = db.collection(watchlistsCollection)
-            .doc(String(userCid))
-            .collection('lists');
-        
-        // Check if auto-generated watchlist already exists
-        const existingWatchlistsSnapshot = await userWatchlistsRef
-            .where('isAutoGenerated', '==', true)
-            .limit(1)
-            .get();
-        
-        let watchlistId;
-        let generatedCount = watchlistItems.length;
-        
-        if (!existingWatchlistsSnapshot.empty) {
-            // Update existing auto-generated watchlist
-            // Replace items entirely to match current copied PIs (sync, not append)
-            const existingDoc = existingWatchlistsSnapshot.docs[0];
-            watchlistId = existingDoc.id;
-            const existingData = existingDoc.data();
-            const existingItems = existingData.items || [];
-            
-            // Create a map of existing items by CID to preserve their addedAt timestamps
-            const existingItemsMap = new Map();
-            for (const item of existingItems) {
-                if (item.cid) {
-                    existingItemsMap.set(item.cid, item);
-                }
-            }
-            
-            // Merge watchlist items, preserving addedAt for existing items
-            const syncedItems = watchlistItems.map(newItem => {
-                const existingItem = existingItemsMap.get(newItem.cid);
-                if (existingItem && existingItem.addedAt) {
-                    // Preserve existing addedAt timestamp
-                    return {
-                        ...newItem,
-                        addedAt: existingItem.addedAt
-                    };
-                }
-                // New item, use current date
-                return {
-                    ...newItem,
-                    addedAt: new Date()
-                };
-            });
-            
-            // Calculate what changed
-            const existingCIDs = new Set(existingItems.map(item => item.cid));
-            const newCIDs = new Set(watchlistItems.map(item => item.cid));
-            
-            const added = watchlistItems.filter(item => !existingCIDs.has(item.cid));
-            const removed = existingItems.filter(item => !newCIDs.has(item.cid));
-            
-            // Replace entire items array to sync with current copied PIs
-            // Also ensure visibility is always private for auto-generated watchlists
-            await existingDoc.ref.update({
-                items: syncedItems, // Full replacement to match current state, preserving timestamps
-                visibility: 'private', // Always enforce private for auto-generated
-                updatedAt: FieldValue.serverTimestamp()
-            });
-            
-            logger.log('SUCCESS', `[autoGenerateWatchlist] Synced auto-generated watchlist ${watchlistId} for user ${userCid}: ${added.length} added, ${removed.length} removed, ${watchlistItems.length} total`);
-        } else {
-            // Create new auto-generated watchlist
-            const crypto = require('crypto');
-            watchlistId = `watchlist_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-            
-            const watchlistData = {
-                id: watchlistId,
-                name: 'My Copy Watchlist', // Hardcoded name as requested
-                type: 'static',
-                visibility: 'private', // Always private for auto-generated watchlists
-                createdBy: Number(userCid),
-                createdAt: FieldValue.serverTimestamp(),
-                updatedAt: FieldValue.serverTimestamp(),
-                isAutoGenerated: true,
-                copyCount: 0,
-                items: watchlistItems
-            };
-            
-            await userWatchlistsRef.doc(watchlistId).set(watchlistData);
-            logger.log('SUCCESS', `[autoGenerateWatchlist] Created auto-generated watchlist ${watchlistId} with ${watchlistItems.length} items for user ${userCid}`);
-        }
-        
-        // 5. Create subscriptions for all items in the watchlist
-        // This will be handled by the subscription system, but we log it here
-        logger.log('INFO', `[autoGenerateWatchlist] Watchlist ${watchlistId} ready for subscription setup (${watchlistItems.length} items)`);
-        
-        return res.status(200).json({
-            success: true,
-            generated: generatedCount,
-            totalCopied: copiedPIs.length,
-            matchedInRankings: matchedCount,
-            dataSource: dataSource,
-            watchlistId: watchlistId,
-            message: `Generated ${generatedCount} watchlist entries from ${copiedPIs.length} copied PIs (${matchedCount} matched in rankings, source: ${dataSource})`
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[autoGenerateWatchlist] Error auto-generating watchlist for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/search/pis
- * Search Popular Investors by username (for autocomplete)
- */
-async function searchPopularInvestors(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { query, limit = 20 } = req.query;
-    
-    if (!query || query.trim().length < 2) {
-        return res.status(400).json({ error: "Query must be at least 2 characters" });
-    }
-    
-    try {
-        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
-        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
-        
-        if (!rankingsDate) {
-            return res.status(404).json({ error: "Rankings data not available" });
-        }
-        
-        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
-        const rankingsDoc = await rankingsRef.get();
-        
-        if (!rankingsDoc.exists) {
-            return res.status(404).json({ error: "Rankings data not available" });
-        }
-        
-        const rankingsData = rankingsDoc.data();
-        const rankingsItems = rankingsData.Items || [];
-        
-        // Search by username (case-insensitive, partial match)
-        const searchQuery = query.toLowerCase().trim();
-        const matches = rankingsItems
-            .filter(item => {
-                const username = (item.UserName || '').toLowerCase();
-                return username.includes(searchQuery);
-            })
-            .slice(0, parseInt(limit))
-            .map(item => ({
-                cid: item.CustomerId,
-                username: item.UserName,
-                aum: item.AUMValue,
-                riskScore: item.RiskScore,
-                gain: item.Gain,
-                copiers: item.Copiers
-            }));
-        
-        return res.status(200).json({
-            results: matches,
-            count: matches.length,
-            query: query
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[searchPopularInvestors] Error searching PIs`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * POST /user/requests/pi-addition
- * Request to add a Popular Investor to the database
- */
-async function requestPiAddition(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid, username, piUsername, piCid } = req.body;
-    
-    if (!userCid || !username || !piUsername) {
-        return res.status(400).json({ error: "Missing required fields: userCid, username, piUsername" });
-    }
-    
-    try {
-        const requestsCollection = config.requestsCollection || 'requests';
-        const requestId = `pi_add_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        
-        const requestData = {
-            id: requestId,
-            type: 'popular_investor_addition',
-            requestedBy: {
-                userCid: Number(userCid),
-                username: username
-            },
-            popularInvestor: {
-                username: piUsername,
-                cid: piCid || null
-            },
-            status: 'pending',
-            requestedAt: FieldValue.serverTimestamp(),
-            processedAt: null,
-            notes: null
-        };
-        
-        const requestRef = db.collection(requestsCollection)
-            .doc('popular_investor_copy_additions')
-            .collection('requests')
-            .doc(requestId);
-        
-        await requestRef.set(requestData);
-        
-        logger.log('SUCCESS', `[requestPiAddition] User ${userCid} requested addition of PI ${piUsername} (CID: ${piCid || 'unknown'})`);
-        
-        return res.status(201).json({
-            success: true,
-            requestId: requestId,
-            message: "Request submitted successfully"
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[requestPiAddition] Error submitting request`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/watchlists/:id/trigger-counts
- * Get alert trigger counts for PIs in a watchlist (last 7 days)
- */
-async function getWatchlistTriggerCounts(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    try {
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const watchlistRef = db.collection(watchlistsCollection)
-            .doc(String(userCid))
-            .collection('lists')
-            .doc(id);
-        
-        const watchlistDoc = await watchlistRef.get();
-        
-        if (!watchlistDoc.exists) {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        const watchlistData = watchlistDoc.data();
-        const items = watchlistData.items || [];
-        
-        // Calculate date 7 days ago (use Firestore Timestamp)
-        const { Timestamp } = require('@google-cloud/firestore');
-        const sevenDaysAgo = new Date();
-        sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
-        const cutoffTimestamp = Timestamp.fromDate(sevenDaysAgo);
-        
-        const triggerCounts = {};
-        const alertTriggersCollection = config.alertTriggersCollection || 'alert_triggers';
-        
-        // For each PI in the watchlist, count triggers in last 7 days
-        for (const item of items) {
-            const piCid = item.cid;
-            const triggersRef = db.collection(alertTriggersCollection)
-                .doc(String(userCid))
-                .collection('triggers')
-                .where('piCid', '==', piCid)
-                .where('triggeredAt', '>', cutoffTimestamp);
-            
-            const triggersSnapshot = await triggersRef.get();
-            triggerCounts[piCid] = triggersSnapshot.size;
-        }
-        
-        return res.status(200).json({
-            triggerCounts,
-            watchlistId: id,
-            period: '7days'
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getWatchlistTriggerCounts] Error fetching trigger counts`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/watchlists/:id/rankings-check
- * Check which PIs in a watchlist are in the latest available rankings
- */
-async function checkPisInRankings(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    try {
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const watchlistRef = db.collection(watchlistsCollection)
-            .doc(String(userCid))
-            .collection('lists')
-            .doc(id);
-        
-        const watchlistDoc = await watchlistRef.get();
-        
-        if (!watchlistDoc.exists) {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        const watchlistData = watchlistDoc.data();
-        const items = watchlistData.items || [];
-        
-        // Find latest available rankings date (with fallback)
-        const rankingsCollection = config.popularInvestorRankingsCollection || process.env.FIRESTORE_COLLECTION_PI_RANKINGS || 'popular_investor_rankings';
-        const rankingsDate = await findLatestRankingsDate(db, rankingsCollection, 30);
-        
-        if (!rankingsDate) {
-            // No rankings data available, assume all PIs are not in rankings
-            const notInRankings = items.map(item => item.cid);
-            return res.status(200).json({
-                notInRankings,
-                rankingsDate: null,
-                message: "No rankings data available"
-            });
-        }
-        
-        // Fetch rankings data from latest available date
-        const rankingsRef = db.collection(rankingsCollection).doc(rankingsDate);
-        const rankingsDoc = await rankingsRef.get();
-        
-        if (!rankingsDoc.exists) {
-            const notInRankings = items.map(item => item.cid);
-            return res.status(200).json({
-                notInRankings,
-                rankingsDate: null,
-                message: "Rankings document not found"
-            });
-        }
-        
-        const rankingsData = rankingsDoc.data();
-        const rankingsItems = rankingsData.Items || [];
-        
-        // Create a set of CIDs that exist in rankings
-        const rankingsCIDs = new Set();
-        for (const item of rankingsItems) {
-            if (item.CustomerId) {
-                rankingsCIDs.add(String(item.CustomerId));
-            }
-        }
-        
-        // Check which watchlist PIs are NOT in rankings
-        const notInRankings = [];
-        for (const item of items) {
-            const cidStr = String(item.cid);
-            if (!rankingsCIDs.has(cidStr)) {
-                notInRankings.push(item.cid);
-            }
-        }
-        
-        return res.status(200).json({
-            notInRankings,
-            rankingsDate: rankingsDate,
-            totalChecked: items.length,
-            inRankings: items.length - notInRankings.length
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[checkPisInRankings] Error checking PIs in rankings`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /pi/:cid/profile
- * Fetches Popular Investor profile data from computation
- * Falls back to latest available date if today's data doesn't exist
- */
-/**
- * Helper function to fetch and check if a specific CID exists in a computation document for a given date
- * Returns { found: boolean, profileData: object | null, computationData: object | null }
- */
-async function checkPiInComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, dateStr, cidStr, logger) {
-    try {
-        const computationRef = db.collection(insightsCollection)
-            .doc(dateStr)
-            .collection(resultsSub)
-            .doc(category)
-            .collection(compsSub)
-            .doc(computationName);
-        
-        const computationDoc = await computationRef.get();
-        
-        if (!computationDoc.exists) {
-            return { found: false, profileData: null, computationData: null };
-        }
-        
-        const rawData = computationDoc.data();
-        let computationData = null;
-        
-        // Check if data is sharded
-        if (rawData._sharded === true && rawData._shardCount) {
-            // Data is stored in shards - read all shards and merge
-            const shardsCol = computationRef.collection('_shards');
-            const shardCount = rawData._shardCount;
-            
-            logger.log('INFO', `[checkPiInComputationDate] Reading ${shardCount} shards for date ${dateStr}`);
-            
-            computationData = {};
-            
-            // Read all shards (shard_0, shard_1, ..., shard_N-1)
-            for (let i = 0; i < shardCount; i++) {
-                const shardDoc = await shardsCol.doc(`shard_${i}`).get();
-                if (shardDoc.exists) {
-                    const shardData = shardDoc.data();
-                    // Merge shard data into computationData
-                    Object.assign(computationData, shardData);
-                } else {
-                    logger.log('WARN', `[checkPiInComputationDate] Shard shard_${i} missing for date ${dateStr}`);
-                }
-            }
-        } else {
-            // Data is in the main document (compressed or raw)
-            computationData = tryDecompress(rawData);
-            
-            // Handle string decompression result
-            if (typeof computationData === 'string') {
-                try {
-                    computationData = JSON.parse(computationData);
-                } catch (e) {
-                    logger.log('WARN', `[checkPiInComputationDate] Failed to parse decompressed string for date ${dateStr}:`, e.message);
-                    return { found: false, profileData: null, computationData: null };
-                }
-            }
-        }
-        
-        // Check if CID exists in the computation data
-        if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
-            // Filter out metadata keys that start with underscore
-            const cids = Object.keys(computationData).filter(key => !key.startsWith('_'));
-            
-            // Check if the requested CID exists
-            const profileData = computationData[cidStr];
-            if (profileData) {
-                logger.log('INFO', `[checkPiInComputationDate] Found CID ${cidStr} in date ${dateStr} (total CIDs: ${cids.length})`);
-                return { found: true, profileData, computationData };
-            } else {
-                logger.log('INFO', `[checkPiInComputationDate] CID ${cidStr} not found in date ${dateStr}. Available CIDs: ${cids.slice(0, 10).join(', ')}${cids.length > 10 ? '...' : ''}`);
-            }
-        }
-        
-        return { found: false, profileData: null, computationData };
-        
-    } catch (error) {
-        logger.log('WARN', `[checkPiInComputationDate] Error checking date ${dateStr}:`, error.message);
-        return { found: false, profileData: null, computationData: null };
-    }
-}
-
-async function getPiProfile(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { cid } = req.params;
-    
-    if (!cid) {
-        return res.status(400).json({ error: "Missing PI CID" });
-    }
-
-    try {
-        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-        const resultsSub = config.resultsSubcollection || 'results';
-        const compsSub = config.computationsSubcollection || 'computations';
-        const computationName = 'PopularInvestorProfileMetrics';
-        const category = 'popular-investor'; // Use hyphen to match Firestore path
-        const today = new Date().toISOString().split('T')[0];
-        const cidStr = String(cid);
-        const maxDaysBackForPi = 7; // Maximum days to search back for a specific PI
-        
-        logger.log('INFO', `[getPiProfile] Starting search for PI CID: ${cid}`);
-        
-        // Find latest available computation date (just check if document exists, not CID)
-        const latestDate = await findLatestComputationDate(
-            db, 
-            insightsCollection,
-            resultsSub,
-            compsSub,
-            category, 
-            computationName, 
-            null, // Don't pass CID - just find if document exists
-            30
-        );
-        
-        logger.log('INFO', `[getPiProfile] Latest computation date found: ${latestDate || 'NONE'}`);
-        
-        if (!latestDate) {
-            logger.log('WARN', `[getPiProfile] No computation document found for ${computationName} in last 30 days`);
-            return res.status(404).json({ 
-                error: "Profile data not available",
-                message: "No computation results found for this Popular Investor"
-            });
-        }
-        
-        // Try to find the PI starting from the latest date, then going back up to 7 days
-        let foundDate = null;
-        let profileData = null;
-        let checkedDates = [];
-        
-        // Parse the latest date to calculate earlier dates
-        const latestDateObj = new Date(latestDate + 'T00:00:00Z');
-        
-        for (let daysBack = 0; daysBack <= maxDaysBackForPi; daysBack++) {
-            const checkDate = new Date(latestDateObj);
-            checkDate.setUTCDate(latestDateObj.getUTCDate() - daysBack);
-            const dateStr = checkDate.toISOString().split('T')[0];
-            checkedDates.push(dateStr);
-            
-            logger.log('INFO', `[getPiProfile] Checking date ${dateStr} for CID ${cid} (${daysBack} days back from latest)`);
-            
-            const result = await checkPiInComputationDate(
-                db,
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category,
-                computationName,
-                dateStr,
-                cidStr,
-                logger
-            );
-            
-            if (result.found) {
-                foundDate = dateStr;
-                profileData = result.profileData;
-                logger.log('SUCCESS', `[getPiProfile] Found profile data for CID ${cid} in date ${dateStr} (${daysBack} days back from latest)`);
-                break;
-            } else {
-                logger.log('INFO', `[getPiProfile] CID ${cid} not found in date ${dateStr}`);
-            }
-        }
-        
-        // If not found in any checked date, return 404
-        if (!foundDate || !profileData) {
-            logger.log('WARN', `[getPiProfile] CID ${cid} not found in any checked dates: ${checkedDates.join(', ')}`);
-            
-            // Try to get sample data from the latest date to show what CIDs are available
-            const latestResult = await checkPiInComputationDate(
-                db,
-                insightsCollection,
-                resultsSub,
-                compsSub,
-                category,
-                computationName,
-                latestDate,
-                cidStr,
-                logger
-            );
-            
-            // Filter out metadata keys (those starting with _) when listing available CIDs
-            const allAvailableCids = latestResult.computationData && typeof latestResult.computationData === 'object' && !Array.isArray(latestResult.computationData)
-                ? Object.keys(latestResult.computationData)
-                    .filter(key => !key.startsWith('_'))
-                    .sort()
-                : [];
-            
-            return res.status(404).json({ 
-                error: "Profile data not found",
-                message: `Popular Investor ${cid} does not exist in computation results for the last ${maxDaysBackForPi + 1} days. This PI may not have been processed recently.`,
-                debug: {
-                    searchedCid: cidStr,
-                    checkedDates: checkedDates,
-                    totalCidsInLatestDocument: allAvailableCids.length,
-                    sampleAvailableCids: allAvailableCids.slice(0, 20), // First 20 for reference
-                    latestDate: latestDate
-                }
-            });
-        }
-        
-        // Get username from rankings
-        const { getPiUsername } = require('./on_demand_fetch_helpers');
-        const username = await getPiUsername(db, cid, config, logger);
-        
-        logger.log('SUCCESS', `[getPiProfile] Returning profile data for CID ${cid} from date ${foundDate} (requested: ${today}, latest available: ${latestDate})`);
-        
-        return res.status(200).json({
-            status: 'success',
-            cid: cidStr,
-            username: username || null,
-            data: profileData,
-            isFallback: foundDate !== latestDate || foundDate !== today,
-            dataDate: foundDate,
-            latestComputationDate: latestDate,
-            requestedDate: today,
-            daysBackFromLatest: checkedDates.indexOf(foundDate)
-        });
-
-    } catch (error) {
-        logger.log('ERROR', `[getPiProfile] Error fetching PI profile for ${cid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/is-popular-investor
- * Check if signed-in user is also a Popular Investor
- * Supports dev override impersonation
- */
-async function checkIfUserIsPopularInvestor(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        const devOverride = await getDevOverride(db, userCid, config, logger);
-        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
-        
-        // Use effective CID (impersonated or actual) to check PI status
-        const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
-        
-        if (!rankEntry) {
-            return res.status(200).json({
-                isPopularInvestor: false,
-                rankingData: null,
-                isImpersonating: isImpersonating || false,
-                effectiveCid: effectiveCid
-            });
-        }
-        
-        // Check if this is a dev override (pretendToBePI)
-        const isDevOverride = devOverride && devOverride.enabled && devOverride.pretendToBePI;
-        
-        // Return ranking data
-        return res.status(200).json({
-            isPopularInvestor: true,
-            rankingData: {
-                cid: rankEntry.CustomerId,
-                username: rankEntry.UserName,
-                aum: rankEntry.AUMValue || 0,
-                copiers: rankEntry.Copiers || 0,
-                riskScore: rankEntry.RiskScore || 0,
-                gain: rankEntry.Gain || 0,
-                winRatio: rankEntry.WinRatio || 0,
-                trades: rankEntry.Trades || 0
-            },
-            isDevOverride: isDevOverride || false,
-            isImpersonating: isImpersonating || false,
-            effectiveCid: effectiveCid,
-            actualCid: Number(userCid)
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[checkIfUserIsPopularInvestor] Error checking PI status for ${userCid}:`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * Track profile page view for a Popular Investor
- * Stores view data for analytics
- */
-async function trackProfileView(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { piCid } = req.params;
-    const { viewerCid, viewerType = 'anonymous' } = req.body; // viewerType: 'anonymous', 'signed_in', 'copier'
-    
-    if (!piCid) {
-        return res.status(400).json({ error: "Missing piCid" });
-    }
-    
-    try {
-        const { getCollectionPath, writeDual } = require('./collection_helpers');
-        const { collectionRegistry } = dependencies;
-        const profileViewsCollection = config.profileViewsCollection || 'profile_views';
-        const today = new Date().toISOString().split('T')[0];
-        
-        // Get existing document to merge unique viewers properly
-        let existingData = {};
-        let existingUniqueViewers = [];
-        
-        if (collectionRegistry) {
-            try {
-                const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'profileViews', {
-                    piCid: String(piCid)
-                }) + `/${today}`;
-                
-                const existingDoc = await db.doc(newPath).get();
-                if (existingDoc.exists) {
-                    existingData = existingDoc.data();
-                    existingUniqueViewers = Array.isArray(existingData.uniqueViewers) ? existingData.uniqueViewers : [];
-                }
-            } catch (newError) {
-                // Continue to legacy check
-            }
-        }
-        
-        // Fallback to legacy check
-        let viewDocId = `${piCid}_${today}`;
-        let viewRef = null;
-        
-        if (existingUniqueViewers.length === 0) {
-            viewRef = db.collection(profileViewsCollection).doc(viewDocId);
-            const existingDoc = await viewRef.get();
-            if (existingDoc.exists) {
-                existingData = existingDoc.data();
-                existingUniqueViewers = Array.isArray(existingData.uniqueViewers) ? existingData.uniqueViewers : [];
-            }
-        }
-        
-        // Add new viewer if provided and not already in list
-        const updatedUniqueViewers = viewerCid && !existingUniqueViewers.includes(String(viewerCid))
-            ? [...existingUniqueViewers, String(viewerCid)]
-            : existingUniqueViewers;
-        
-        const viewData = {
-            piCid: Number(piCid),
-            date: today,
-            totalViews: FieldValue.increment(1),
-            uniqueViewers: updatedUniqueViewers, // Store as array, not using arrayUnion to avoid duplicates
-            lastUpdated: FieldValue.serverTimestamp()
-        };
-        
-        // Write to both new and legacy structures
-        if (collectionRegistry) {
-            const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'profileViews', {
-                piCid: String(piCid)
-            }) + `/${today}`;
-            
-            const legacyPath = `${profileViewsCollection}/${viewDocId}`;
-            
-            await writeDual(db, newPath, legacyPath, viewData, { isCollection: false, merge: true });
-        } else {
-            if (!viewRef) {
-                viewRef = db.collection(profileViewsCollection).doc(viewDocId);
-            }
-            await viewRef.set(viewData, { merge: true });
-        }
-        
-        // Also track individual view for detailed analytics (optional, lightweight)
-        if (viewerCid) {
-            const individualViewId = `${piCid}_${viewerCid}_${Date.now()}`;
-            const individualViewData = {
-                piCid: Number(piCid),
-                viewerCid: Number(viewerCid),
-                viewerType: viewerType,
-                viewedAt: FieldValue.serverTimestamp(),
-                date: today
-            };
-            
-            if (collectionRegistry) {
-                const newViewPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'individualViews', {
-                    piCid: String(piCid)
-                }) + `/${individualViewId}`;
-                
-                const legacyViewPath = `${profileViewsCollection}/individual_views/views/${individualViewId}`;
-                
-                await writeDual(db, newViewPath, legacyViewPath, individualViewData);
-            } else {
-                await db.collection(profileViewsCollection)
-                    .doc('individual_views')
-                    .collection('views')
-                    .doc(individualViewId)
-                    .set(individualViewData, { merge: true });
-            }
-        }
-        
-        return res.status(200).json({ success: true, message: "View tracked" });
-        
-    } catch (error) {
-        logger.log('ERROR', `[trackProfileView] Error tracking view for PI ${piCid}:`, error);
-        // Don't fail the request if tracking fails
-        return res.status(200).json({ success: false, message: "View tracking failed but request succeeded" });
-    }
-}
-
-/**
- * Generate sample PI personalized metrics data for dev testing
- * Creates realistic sample data that matches the computation structure 1:1
- */
-function generateSamplePIPersonalizedMetrics(userCid, rankEntry) {
-    const today = new Date().toISOString().split('T')[0];
-    const yesterday = new Date();
-    yesterday.setDate(yesterday.getDate() - 1);
-    const yesterdayStr = yesterday.toISOString().split('T')[0];
-    
-    // Generate sample base metrics (from PopularInvestorProfileMetrics)
-    const baseMetrics = {
-        socialEngagement: {
-            chartType: 'line',
-            data: Array.from({ length: 30 }, (_, i) => {
-                const date = new Date();
-                date.setDate(date.getDate() - (29 - i));
-                return {
-                    date: date.toISOString().split('T')[0],
-                    likes: Math.floor(Math.random() * 50) + 10,
-                    comments: Math.floor(Math.random() * 20) + 5
-                };
-            })
-        },
-        profitablePositions: {
-            chartType: 'bar',
-            data: Array.from({ length: 30 }, (_, i) => {
-                const date = new Date();
-                date.setDate(date.getDate() - (29 - i));
-                return {
-                    date: date.toISOString().split('T')[0],
-                    profitableCount: Math.floor(Math.random() * 10) + 5,
-                    totalCount: Math.floor(Math.random() * 15) + 10
-                };
-            })
-        },
-        topWinningPositions: {
-            chartType: 'table',
-            data: Array.from({ length: 10 }, (_, i) => ({
-                instrumentId: 1000 + i,
-                ticker: ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'NFLX', 'AMD', 'INTC'][i],
-                netProfit: Math.floor(Math.random() * 100) + 20,
-                invested: Math.floor(Math.random() * 5000) + 1000,
-                value: Math.floor(Math.random() * 6000) + 1000,
-                isCurrent: Math.random() > 0.5,
-                closeDate: Math.random() > 0.5 ? new Date().toISOString() : null
-            }))
-        },
-        sectorPerformance: {
-            bestSector: 'Technology',
-            worstSector: 'Energy',
-            bestSectorProfit: 15.5,
-            worstSectorProfit: -3.2
-        },
-        sectorExposure: {
-            chartType: 'pie',
-            data: {
-                'Technology': 35.5,
-                'Healthcare': 20.3,
-                'Finance': 15.2,
-                'Energy': 10.1,
-                'Consumer': 18.9
-            }
-        },
-        assetExposure: {
-            chartType: 'pie',
-            data: {
-                'AAPL': 12.5,
-                'MSFT': 10.3,
-                'GOOGL': 8.7,
-                'AMZN': 7.2,
-                'TSLA': 6.1
-            }
-        },
-        portfolioSummary: {
-            totalInvested: 850000,
-            totalProfit: 125000,
-            profitPercent: 14.7
-        },
-        rankingsData: {
-            aum: rankEntry.AUMValue || 0,
-            riskScore: rankEntry.RiskScore || 0,
-            gain: rankEntry.Gain || 0,
-            copiers: rankEntry.Copiers || 0,
-            winRatio: rankEntry.WinRatio || 0,
-            trades: rankEntry.Trades || 0
-        }
-    };
-    
-    // Generate sample review metrics
-    const reviewMetricsOverTime = Array.from({ length: 30 }, (_, i) => {
-        const date = new Date();
-        date.setDate(date.getDate() - (29 - i));
-        return {
-            date: date.toISOString().split('T')[0],
-            averageRating: Number((3.5 + Math.random() * 1.5).toFixed(2)),
-            count: Math.floor(Math.random() * 5) + 1
-        };
-    });
-    
-    const totalReviews = reviewMetricsOverTime.reduce((sum, r) => sum + r.count, 0);
-    const avgRating = reviewMetricsOverTime.reduce((sum, r) => sum + (r.averageRating * r.count), 0) / totalReviews;
-    
-    // Generate sample similar PIs
-    const similarPIs = Array.from({ length: 5 }, (_, i) => ({
-        cid: 1000000 + i,
-        username: `SimilarPI${i + 1}`,
-        similarityScore: Number((85 - (i * 5)).toFixed(2)),
-        aum: Math.floor(Math.random() * 500000) + 300000,
-        copiers: Math.floor(Math.random() * 200) + 100,
-        riskScore: Math.floor(Math.random() * 3) + 2,
-        gain: Number((20 + Math.random() * 30).toFixed(2))
-    }));
-    
-    // Calculate leaderboard position (sample)
-    const totalPIs = 1000;
-    const currentRank = Math.floor(Math.random() * 200) + 50; // Rank 50-250
-    const percentile = Number((100 - ((currentRank / totalPIs) * 100)).toFixed(2));
-    
-    // Generate sample asset investments
-    const topAssets = Array.from({ length: 10 }, (_, i) => ({
-        instrumentId: 1000 + i,
-        ticker: ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'NFLX', 'AMD', 'INTC'][i],
-        aum: Math.floor(Math.random() * 100000) + 50000,
-        percentage: Number((Math.random() * 15 + 5).toFixed(2))
-    }));
-    
-    // Generate sample profile views
-    const profileViewsOverTime = Array.from({ length: 30 }, (_, i) => {
-        const date = new Date();
-        date.setDate(date.getDate() - (29 - i));
-        return {
-            date: date.toISOString().split('T')[0],
-            views: Math.floor(Math.random() * 50) + 10,
-            uniqueViews: Math.floor(Math.random() * 30) + 5
-        };
-    });
-    
-    const totalViews = profileViewsOverTime.reduce((sum, v) => sum + v.views, 0);
-    const totalUniqueViews = new Set(profileViewsOverTime.flatMap(v => Array.from({ length: v.uniqueViews }, (_, i) => `viewer_${i}`))).size;
-    const averageDailyViews = Number((totalViews / 30).toFixed(2));
-    
-    // Calculate copier growth
-    const copiersToday = rankEntry.Copiers || 250;
-    const copiersYesterday = copiersToday - Math.floor(Math.random() * 20) + 5; // Random change
-    const diff = copiersToday - copiersYesterday;
-    const growthRate = copiersYesterday > 0 ? Number(((diff / copiersYesterday) * 100).toFixed(2)) : 0;
-    const trend = diff > 0 ? 'increasing' : diff < 0 ? 'decreasing' : 'stable';
-    
-    // Calculate engagement score
-    const reviewScore = avgRating * 20; // 0-100 scale
-    const viewScore = Math.min(100, (averageDailyViews / 10) * 100);
-    const copierScore = Math.min(100, (copiersToday / 1000) * 100);
-    const socialScore = Math.min(100, (baseMetrics.socialEngagement.data.length / 10) * 100);
-    const engagementScore = (reviewScore * 0.3 + viewScore * 0.2 + copierScore * 0.3 + socialScore * 0.2);
-    
-    return {
-        baseMetrics: baseMetrics,
-        reviewMetrics: {
-            overTime: reviewMetricsOverTime,
-            currentStats: {
-                averageRating: Number(avgRating.toFixed(2)),
-                totalReviews: totalReviews,
-                distribution: {
-                    1: Math.floor(totalReviews * 0.1),
-                    2: Math.floor(totalReviews * 0.15),
-                    3: Math.floor(totalReviews * 0.25),
-                    4: Math.floor(totalReviews * 0.3),
-                    5: Math.floor(totalReviews * 0.2)
-                }
-            },
-            sentimentTrend: []
-        },
-        similarPIs: similarPIs,
-        leaderboardPosition: {
-            currentRank: currentRank,
-            totalPIs: totalPIs,
-            percentile: percentile,
-            rankByAUM: currentRank + Math.floor(Math.random() * 50) - 25,
-            rankByCopiers: currentRank
-        },
-        assetInvestments: {
-            byAUM: topAssets.reduce((acc, asset) => {
-                acc[asset.instrumentId] = asset.aum;
-                return acc;
-            }, {}),
-            topAssets: topAssets
-        },
-        profileViews: {
-            overTime: profileViewsOverTime,
-            totalViews: totalViews,
-            totalUniqueViews: totalUniqueViews,
-            averageDailyViews: averageDailyViews
-        },
-        copierGrowth: {
-            overTime: [
-                { date: yesterdayStr, copiers: copiersYesterday },
-                { date: today, copiers: copiersToday }
-            ],
-            growthRate: growthRate,
-            diff: diff,
-            trend: trend
-        },
-        engagementScore: {
-            current: Number(engagementScore.toFixed(2)),
-            components: {
-                reviewScore: Number(reviewScore.toFixed(2)),
-                viewScore: Number(viewScore.toFixed(2)),
-                copierScore: Number(copierScore.toFixed(2)),
-                socialScore: Number(socialScore.toFixed(2))
-            }
-        }
-    };
-}
-
-/**
- * GET /user/me/pi-personalized-metrics
- * Get personalized metrics for signed-in user who is a Popular Investor
- * Includes review metrics, page views, similar PIs, leaderboard position, etc.
- */
-async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    try {
-        // Check for dev override impersonation
-        const { getEffectiveCid, getDevOverride } = require('./dev_helpers');
-        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
-        const devOverride = await getDevOverride(db, userCid, config, logger);
-        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
-        
-        // Use effective CID (impersonated or actual) to check PI status
-        const rankEntry = await checkIfUserIsPI(db, effectiveCid, config, logger);
-        if (!rankEntry) {
-            return res.status(404).json({
-                error: "Not a Popular Investor",
-                message: "This endpoint is only available for users who are Popular Investors",
-                effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
-            });
-        }
-        
-        // Check if this is a dev override (pretendToBePI)
-        const isDevOverride = devOverride && devOverride.enabled && devOverride.pretendToBePI;
-        
-        // If dev override (pretendToBePI), generate sample data
-        if (isDevOverride) {
-            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] DEV OVERRIDE: Generating sample PI metrics for effective CID ${effectiveCid}`);
-            const sampleData = generateSamplePIPersonalizedMetrics(effectiveCid, rankEntry);
-            const today = new Date().toISOString().split('T')[0];
-            
-            return res.status(200).json({
-                status: 'success',
-                userCid: String(effectiveCid),
-                data: sampleData,
-                dataDate: today,
-                requestedDate: today,
-                isFallback: false,
-                isDevOverride: true,
-                isImpersonating: isImpersonating || false,
-                actualCid: Number(userCid)
-            });
-        }
-        
-        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-        const resultsSub = config.resultsSubcollection || 'results';
-        const compsSub = config.computationsSubcollection || 'computations';
-        const category = 'popular-investor';
-        const computationName = 'SignedInUserPIPersonalizedMetrics';
-        const today = new Date().toISOString().split('T')[0];
-        
-        // Try to find computation with user-specific fallback logic
-        // Use effectiveCid (impersonated or actual) for computation lookup
-        let foundDate = null;
-        let metricsData = null;
-        let checkedDates = [];
-        
-        // Step 1: Try today, then look back 30 days for computation document
-        const latestComputationDate = await findLatestComputationDate(
-            db,
-            insightsCollection,
-            resultsSub,
-            compsSub,
-            category,
-            computationName,
-            null, // Don't check for specific user yet
-            30
-        );
-        
-        if (!latestComputationDate) {
-            // No computation exists at all - will fallback to frontend
-            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] No computation document found, will use frontend fallback`);
-            return res.status(200).json({
-                status: 'fallback',
-                message: 'Computation not available, use frontend fallback',
-                data: null,
-                useFrontendFallback: true,
-                effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
-            });
-        }
-        
-        // Step 2: Check if user exists in latest computation, if not, look back 7 days
-        // Use effectiveCid for lookup
-        const latestDateObj = new Date(latestComputationDate + 'T00:00:00Z');
-        
-        for (let daysBack = 0; daysBack <= 7; daysBack++) {
-            const checkDate = new Date(latestDateObj);
-            checkDate.setUTCDate(latestDateObj.getUTCDate() - daysBack);
-            const dateStr = checkDate.toISOString().split('T')[0];
-            checkedDates.push(dateStr);
-            
-            const computationRef = db.collection(insightsCollection)
-                .doc(dateStr)
-                .collection(resultsSub)
-                .doc(category)
-                .collection(compsSub)
-                .doc(computationName);
-            
-            const computationDoc = await computationRef.get();
-            
-            if (computationDoc.exists) {
-                const rawData = computationDoc.data();
-                let computationData = tryDecompress(rawData);
-                
-                if (typeof computationData === 'string') {
-                    try {
-                        computationData = JSON.parse(computationData);
-                    } catch (e) {
-                        continue;
-                    }
-                }
-                
-                // Check if user exists in this computation (use effectiveCid)
-                if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
-                    const userData = computationData[String(effectiveCid)];
-                    if (userData) {
-                        foundDate = dateStr;
-                        metricsData = userData;
-                        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Found effective CID ${effectiveCid} in computation date ${dateStr}`);
-                        break;
-                    }
-                }
-            }
-        }
-        
-        // Step 3: If user not found in any computation, return fallback flag
-        if (!foundDate || !metricsData) {
-            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Effective CID ${effectiveCid} not found in any computation, will use frontend fallback`);
-            return res.status(200).json({
-                status: 'fallback',
-                message: 'User not found in computation, use frontend fallback',
-                data: null,
-                useFrontendFallback: true,
-                checkedDates: checkedDates,
-                effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
-            });
-        }
-        
-        // Step 4: Enhance with review metrics and page views from Firestore
-        // These require cross-collection queries that aren't in computation
-        // Use effectiveCid for queries
-        
-        // Fetch review metrics over time
-        const reviewsCollection = config.reviewsCollection || 'pi_reviews';
-        const reviewsSnapshot = await db.collection(reviewsCollection)
-            .where('piCid', '==', Number(effectiveCid))
-            .orderBy('createdAt', 'desc')
-            .limit(1000) // Get enough for time series
-            .get();
-        
-        const reviewTimeMap = new Map();
-        let totalReviews = 0;
-        let totalRating = 0;
-        const ratingDistribution = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
-        
-        reviewsSnapshot.forEach(doc => {
-            const review = doc.data();
-            const rating = review.rating || 0;
-            totalReviews++;
-            totalRating += rating;
-            ratingDistribution[rating] = (ratingDistribution[rating] || 0) + 1;
-            
-            if (review.createdAt) {
-                const reviewDate = review.createdAt.toDate ? review.createdAt.toDate().toISOString().split('T')[0] : review.createdAt;
-                const existing = reviewTimeMap.get(reviewDate) || { date: reviewDate, count: 0, totalRating: 0 };
-                existing.count++;
-                existing.totalRating += rating;
-                reviewTimeMap.set(reviewDate, existing);
-            }
-        });
-        
-        const reviewMetricsOverTime = Array.from(reviewTimeMap.values())
-            .map(entry => ({
-                date: entry.date,
-                averageRating: entry.count > 0 ? Number((entry.totalRating / entry.count).toFixed(2)) : 0,
-                count: entry.count
-            }))
-            .sort((a, b) => a.date.localeCompare(b.date));
-        
-        metricsData.reviewMetrics = {
-            overTime: reviewMetricsOverTime,
-            currentStats: {
-                averageRating: totalReviews > 0 ? Number((totalRating / totalReviews).toFixed(2)) : 0,
-                totalReviews: totalReviews,
-                distribution: ratingDistribution
-            },
-            sentimentTrend: [] // Could analyze review text sentiment if needed
-        };
-        
-        // Fetch profile views over time
-        const profileViewsCollection = config.profileViewsCollection || 'profile_views';
-        // Query without orderBy first, then sort in memory (to avoid index requirement)
-        // Use effectiveCid for queries
-        const viewsSnapshot = await db.collection(profileViewsCollection)
-            .where('piCid', '==', Number(effectiveCid))
-            .limit(90) // Last 90 days worth of documents
-            .get();
-        
-        const viewsOverTime = [];
-        let totalViews = 0;
-        let totalUniqueViews = 0;
-        const uniqueViewersSet = new Set();
-        const viewsByDate = new Map();
-        
-        viewsSnapshot.forEach(doc => {
-            const viewData = doc.data();
-            const date = viewData.date;
-            if (!date) return;
-            
-            const views = typeof viewData.totalViews === 'number' ? viewData.totalViews : 0;
-            const uniqueViewers = Array.isArray(viewData.uniqueViewers) ? viewData.uniqueViewers : [];
-            
-            // Aggregate by date (in case there are multiple docs per date)
-            const existing = viewsByDate.get(date) || { date, views: 0, uniqueViewers: [] };
-            existing.views += views;
-            existing.uniqueViewers = [...new Set([...existing.uniqueViewers, ...uniqueViewers])];
-            viewsByDate.set(date, existing);
-        });
-        
-        // Convert map to array and calculate totals
-        for (const [date, data] of viewsByDate.entries()) {
-            totalViews += data.views;
-            data.uniqueViewers.forEach(v => uniqueViewersSet.add(v));
-            
-            viewsOverTime.push({
-                date: date,
-                views: data.views,
-                uniqueViews: data.uniqueViewers.length
-            });
-        }
-        
-        totalUniqueViews = uniqueViewersSet.size;
-        const averageDailyViews = viewsOverTime.length > 0 ? Number((totalViews / viewsOverTime.length).toFixed(2)) : 0;
-        
-        metricsData.profileViews = {
-            overTime: viewsOverTime.sort((a, b) => a.date.localeCompare(b.date)),
-            totalViews: totalViews,
-            totalUniqueViews: totalUniqueViews,
-            averageDailyViews: averageDailyViews
-        };
-        
-        // Calculate engagement score
-        const reviewScore = metricsData.reviewMetrics.currentStats.averageRating * 20; // 0-100 scale
-        const viewScore = Math.min(100, (averageDailyViews / 10) * 100); // Cap at 100 for 10+ daily views
-        const copierScore = rankEntry.Copiers ? Math.min(100, (rankEntry.Copiers / 1000) * 100) : 0; // Cap at 100 for 1000+ copiers
-        const socialScore = metricsData.baseMetrics?.socialEngagement?.data?.length > 0 ? Math.min(100, (metricsData.baseMetrics.socialEngagement.data.length / 10) * 100) : 0;
-        
-        const engagementScore = (reviewScore * 0.3 + viewScore * 0.2 + copierScore * 0.3 + socialScore * 0.2);
-        
-        metricsData.engagementScore = {
-            current: Number(engagementScore.toFixed(2)),
-            components: {
-                reviewScore: Number(reviewScore.toFixed(2)),
-                viewScore: Number(viewScore.toFixed(2)),
-                copierScore: Number(copierScore.toFixed(2)),
-                socialScore: Number(socialScore.toFixed(2))
-            }
-        };
-        
-        logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Returning personalized metrics for effective CID ${effectiveCid} from date ${foundDate}`);
-        
-        return res.status(200).json({
-            status: 'success',
-            userCid: String(effectiveCid),
-            data: metricsData,
-            dataDate: foundDate,
-            requestedDate: today,
-            isFallback: foundDate !== today,
-            daysBackFromLatest: checkedDates.indexOf(foundDate),
-            isImpersonating: isImpersonating || false,
-            actualCid: Number(userCid)
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getSignedInUserPIPersonalizedMetrics] Error fetching personalized metrics for ${userCid}:`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
+ * @fileoverview Data Helpers - Re-export Hub
+ * This file re-exports all helper functions from organized modules for backward compatibility.
+ * All functions have been refactored into organized modules with migration support.
+ * 
+ * New code should import directly from the organized modules:
+ * - core/ - Core utilities (compression, data lookup, user status, path resolution)
+ * - data/ - Data endpoints (portfolio, social, computation, instrument)
+ * - profile/ - Profile endpoints (PI profile, user profile, profile views)
+ * - watchlist/ - Watchlist endpoints (legacy, generation, analytics)
+ * - search/ - Search endpoints (PI search, PI requests)
+ * - recommendations/ - Recommendation endpoints
+ * - metrics/ - Metrics endpoints
+ */
+
+// Import from organized modules
+const portfolioHelpers = require('./data/portfolio_helpers');
+const socialHelpers = require('./data/social_helpers');
+const computationHelpers = require('./data/computation_helpers');
+const instrumentHelpers = require('./data/instrument_helpers');
+const piProfileHelpers = require('./profile/pi_profile_helpers');
+const userProfileHelpers = require('./profile/user_profile_helpers');
+const profileViewHelpers = require('./profile/profile_view_helpers');
+const watchlistDataHelpers = require('./watchlist/watchlist_data_helpers');
+const watchlistGenerationHelpers = require('./watchlist/watchlist_generation_helpers');
+const watchlistAnalyticsHelpers = require('./watchlist/watchlist_analytics_helpers');
+const piSearchHelpers = require('./search/pi_search_helpers');
+const piRequestHelpers = require('./search/pi_request_helpers');
+const recommendationHelpers = require('./recommendations/recommendation_helpers');
+const metricsHelpers = require('./metrics/personalized_metrics_helpers');
+
+// Import core helpers
+const { tryDecompress } = require('./core/compression_helpers');
+const { 
+    findLatestRankingsDate, 
+    findLatestPortfolioDate, 
+    findLatestComputationDate,
+    findLatestPiPortfolioDate,
+    findLatestPiHistoryDate 
+} = require('./core/data_lookup_helpers');
+const { checkIfUserIsPI } = require('./core/user_status_helpers');
+const { checkPiInComputationDate } = require('./data/computation_helpers');
+
+// Re-export all functions for backward compatibility
 module.exports = { 
-    getPiAnalytics, 
-    getUserRecommendations,
-    getWatchlist,
-    updateWatchlist,
-    autoGenerateWatchlist,
-    getUserDataStatus,
-    getUserPortfolio,
-    getUserSocialPosts,
-    getUserComputations,
-    getUserVerification,
-    getInstrumentMappings,
-    searchPopularInvestors,
-    requestPiAddition,
-    getWatchlistTriggerCounts,
-    checkPisInRankings,
-    getPiProfile,
-    checkIfUserIsPopularInvestor,
-    checkIfUserIsPI, // Export for use in review_helpers
-    findLatestRankingsDate, // Export for use in on_demand_fetch_helpers
-    tryDecompress, // Export for use in on_demand_fetch_helpers
-    trackProfileView,
-    getSignedInUserPIPersonalizedMetrics
-};
+    // Data helpers
+    getUserPortfolio: portfolioHelpers.getUserPortfolio,
+    getUserDataStatus: portfolioHelpers.getUserDataStatus,
+    getUserSocialPosts: socialHelpers.getUserSocialPosts,
+    getUserComputations: computationHelpers.getUserComputations,
+    getInstrumentMappings: instrumentHelpers.getInstrumentMappings,
+    checkPiInComputationDate,
+    
+    // Profile helpers
+    getPiAnalytics: piProfileHelpers.getPiAnalytics,
+    getPiProfile: piProfileHelpers.getPiProfile,
+    getUserVerification: userProfileHelpers.getUserVerification,
+    checkIfUserIsPopularInvestor: userProfileHelpers.checkIfUserIsPopularInvestor,
+    trackProfileView: profileViewHelpers.trackProfileView,
+    
+    // Watchlist helpers
+    getWatchlist: watchlistDataHelpers.getWatchlist,
+    updateWatchlist: watchlistDataHelpers.updateWatchlist,
+    autoGenerateWatchlist: watchlistGenerationHelpers.autoGenerateWatchlist,
+    getWatchlistTriggerCounts: watchlistAnalyticsHelpers.getWatchlistTriggerCounts,
+    
+    // Search helpers
+    searchPopularInvestors: piSearchHelpers.searchPopularInvestors,
+    requestPiAddition: piRequestHelpers.requestPiAddition,
+    checkPisInRankings: piRequestHelpers.checkPisInRankings,
+    
+    // Recommendations helpers
+    getUserRecommendations: recommendationHelpers.getUserRecommendations,
+    
+    // Metrics helpers
+    getSignedInUserPIPersonalizedMetrics: metricsHelpers.getSignedInUserPIPersonalizedMetrics,
+    generateSamplePIPersonalizedMetrics: metricsHelpers.generateSamplePIPersonalizedMetrics,
+    
+    // Core utilities (for use in other helpers)
+    tryDecompress,
+    findLatestRankingsDate,
+    findLatestPortfolioDate,
+    findLatestComputationDate,
+    findLatestPiPortfolioDate,
+    findLatestPiHistoryDate,
+    checkIfUserIsPI
+};