bulltrackers-module 1.0.423 → 1.0.424

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

@@ -567,20 +567,30 @@ async function getUserPortfolio(req, res, dependencies, config) {
     }
 
     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.impersonateCid && effectiveCid !== Number(userCid);
+        
         const { signedInUsersCollection } = config;
         const CANARY_BLOCK_ID = '19M';
         const today = new Date().toISOString().split('T')[0];
         
-        // Try to find latest available date (starts with today, falls back if needed)
-        const dataDate = await findLatestPortfolioDate(db, signedInUsersCollection, userCid, 30);
+        // Use effective CID for portfolio lookup
+        const dataDate = await findLatestPortfolioDate(db, signedInUsersCollection, effectiveCid, 30);
         
         if (!dataDate) {
-            return res.status(404).json({ error: "Portfolio data not found for this user (checked last 30 days)" });
+            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 user ${userCid} (today: ${today})`);
+            logger.log('INFO', `[getUserPortfolio] Using fallback date ${dataDate} for effective CID ${effectiveCid} (today: ${today})`);
         }
         
         // Fetch portfolio from signed_in_users/19M/snapshots/{date}/parts/part_X
@@ -594,11 +604,11 @@ async function getUserPortfolio(req, res, dependencies, config) {
         
         let portfolioData = null;
         
-        // Search through all parts to find the user's portfolio
+        // 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[String(userCid)]) {
-                portfolioData = partData[String(userCid)];
+            if (partData && partData[String(effectiveCid)]) {
+                portfolioData = partData[String(effectiveCid)];
                 break;
             }
         }
@@ -773,6 +783,12 @@ async function getUserComputations(req, res, dependencies, config) {
     }
 
     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.impersonateCid && effectiveCid !== Number(userCid);
+        
         const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
         const resultsSub = config.resultsSubcollection || 'results';
         const compsSub = config.computationsSubcollection || 'computations';
@@ -789,14 +805,13 @@ async function getUserComputations(req, res, dependencies, config) {
             return res.status(400).json({ error: "Please specify at least one computation name" });
         }
         
-        // Check for dev override (for developer accounts)
-        const { getDevOverride } = require('./dev_helpers');
-        const devOverride = await getDevOverride(db, userCid, config, logger);
+        // 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
         if (mode === 'latest') {
             const firstCompName = computationNames[0];
             const latestDate = await findLatestComputationDate(
@@ -806,25 +821,27 @@ async function getUserComputations(req, res, dependencies, config) {
                 compsSub,
                 category, 
                 firstCompName, 
-                userCid, 
+                effectiveCid, 
                 30
             );
             
             if (latestDate) {
                 datesToCheck = [latestDate];
                 if (latestDate !== today) {
-                    logger.log('INFO', `[getUserComputations] Using fallback date ${latestDate} for user ${userCid} (today: ${today})`);
+                    logger.log('INFO', `[getUserComputations] Using fallback date ${latestDate} for effective CID ${effectiveCid} (today: ${today})`);
                 }
             } else {
                 // No data found, return empty
                 return res.status(200).json({
                     status: 'success',
-                    userCid: String(userCid),
+                    userCid: String(effectiveCid),
                     mode,
                     computations: computationNames,
                     data: {},
                     isFallback: false,
-                    requestedDate: today
+                    requestedDate: today,
+                    isImpersonating: isImpersonating || false,
+                    actualCid: Number(userCid)
                 });
             }
         } else if (mode === 'series') {
@@ -861,9 +878,10 @@ async function getUserComputations(req, res, dependencies, config) {
                         const rawData = doc.data();
                         const data = tryDecompress(rawData);
                         // Filter by user CID - computation results are stored as { cid: result }
-                        let userResult = data[String(userCid)];
+                        // Use effectiveCid for lookup
+                        let userResult = data[String(effectiveCid)];
                         
-                        // Apply dev override for computations that include copied PIs
+                        // 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
@@ -923,13 +941,15 @@ async function getUserComputations(req, res, dependencies, config) {
         
         return res.status(200).json({
             status: 'success',
-            userCid: String(userCid),
+            userCid: String(effectiveCid),
             mode,
             computations: computationNames,
             data: cleanedResults,
             isFallback: isFallback,
             requestedDate: today,
-            devOverrideActive: isDevOverrideActive
+            devOverrideActive: isDevOverrideActive,
+            isImpersonating: isImpersonating || false,
+            actualCid: Number(userCid)
         });
 
     } catch (error) {
@@ -1001,7 +1021,8 @@ async function autoGenerateWatchlist(req, res, dependencies, config) {
                 
                 if (computationDoc.exists) {
                     const computationData = computationDoc.data();
-                    const userResult = computationData[String(userCid)];
+                    // Use effectiveCid for lookup
+                    const userResult = computationData[String(effectiveCid)];
                     
                     if (userResult && userResult.current && userResult.current.length > 0) {
                         // Convert computation result to our format
@@ -1742,6 +1763,7 @@ async function getPiProfile(req, res, dependencies, config) {
 /**
  * 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;
@@ -1752,18 +1774,25 @@ async function checkIfUserIsPopularInvestor(req, res, dependencies, config) {
     }
     
     try {
-        const rankEntry = await checkIfUserIsPI(db, userCid, config, logger);
+        // 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.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
+                rankingData: null,
+                isImpersonating: isImpersonating || false,
+                effectiveCid: effectiveCid
             });
         }
         
-        // Check if this is a dev override
-        const { getDevOverride } = require('./dev_helpers');
-        const devOverride = await getDevOverride(db, userCid, config, logger);
+        // Check if this is a dev override (pretendToBePI)
         const isDevOverride = devOverride && devOverride.pretendToBePI;
         
         // Return ranking data
@@ -1779,7 +1808,10 @@ async function checkIfUserIsPopularInvestor(req, res, dependencies, config) {
                 winRatio: rankEntry.WinRatio || 0,
                 trades: rankEntry.Trades || 0
             },
-            isDevOverride: isDevOverride || false
+            isDevOverride: isDevOverride || false,
+            isImpersonating: isImpersonating || false,
+            effectiveCid: effectiveCid,
+            actualCid: Number(userCid)
         });
         
     } catch (error) {
@@ -2084,34 +2116,42 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
     }
     
     try {
-        // First, verify user is a PI (checks dev override)
-        const rankEntry = await checkIfUserIsPI(db, userCid, config, logger);
+        // 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.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"
+                message: "This endpoint is only available for users who are Popular Investors",
+                effectiveCid: effectiveCid,
+                isImpersonating: isImpersonating || false
             });
         }
         
-        // Check if this is a dev override
-        const { getDevOverride } = require('./dev_helpers');
-        const devOverride = await getDevOverride(db, userCid, config, logger);
+        // Check if this is a dev override (pretendToBePI)
         const isDevOverride = devOverride && devOverride.pretendToBePI;
         
-        // If dev override, generate sample data
+        // If dev override (pretendToBePI), generate sample data
         if (isDevOverride) {
-            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] DEV OVERRIDE: Generating sample PI metrics for user ${userCid}`);
-            const sampleData = generateSamplePIPersonalizedMetrics(userCid, rankEntry);
+            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(userCid),
+                userCid: String(effectiveCid),
                 data: sampleData,
                 dataDate: today,
                 requestedDate: today,
                 isFallback: false,
-                isDevOverride: true
+                isDevOverride: true,
+                isImpersonating: isImpersonating || false,
+                actualCid: Number(userCid)
             });
         }
         
@@ -2123,6 +2163,7 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
         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 = [];
@@ -2146,11 +2187,14 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
                 status: 'fallback',
                 message: 'Computation not available, use frontend fallback',
                 data: null,
-                useFrontendFallback: true
+                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++) {
@@ -2180,13 +2224,13 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
                     }
                 }
                 
-                // Check if user exists in this computation
+                // Check if user exists in this computation (use effectiveCid)
                 if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
-                    const userData = computationData[String(userCid)];
+                    const userData = computationData[String(effectiveCid)];
                     if (userData) {
                         foundDate = dateStr;
                         metricsData = userData;
-                        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Found user ${userCid} in computation date ${dateStr}`);
+                        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Found effective CID ${effectiveCid} in computation date ${dateStr}`);
                         break;
                     }
                 }
@@ -2195,23 +2239,26 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
         
         // Step 3: If user not found in any computation, return fallback flag
         if (!foundDate || !metricsData) {
-            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] User ${userCid} not found in any computation, will use frontend fallback`);
+            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
+                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(userCid))
+            .where('piCid', '==', Number(effectiveCid))
             .orderBy('createdAt', 'desc')
             .limit(1000) // Get enough for time series
             .get();
@@ -2258,8 +2305,9 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
         // 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(userCid))
+            .where('piCid', '==', Number(effectiveCid))
             .limit(90) // Last 90 days worth of documents
             .get();
         
@@ -2324,16 +2372,18 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
             }
         };
         
-        logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Returning personalized metrics for user ${userCid} from date ${foundDate}`);
+        logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Returning personalized metrics for effective CID ${effectiveCid} from date ${foundDate}`);
         
         return res.status(200).json({
             status: 'success',
-            userCid: String(userCid),
+            userCid: String(effectiveCid),
             data: metricsData,
             dataDate: foundDate,
             requestedDate: today,
             isFallback: foundDate !== today,
-            daysBackFromLatest: checkedDates.indexOf(foundDate)
+            daysBackFromLatest: checkedDates.indexOf(foundDate),
+            isImpersonating: isImpersonating || false,
+            actualCid: Number(userCid)
         });
         
     } catch (error) {

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

@@ -40,6 +40,7 @@ async function getDevOverride(db, userCid, config, logger = null) {
                 enabled: false,
                 fakeCopiedPIs: [],
                 pretendToBePI: false,
+                impersonateCid: null, // CID to impersonate/view as
                 createdAt: FieldValue.serverTimestamp(),
                 lastUpdated: FieldValue.serverTimestamp()
             };
@@ -58,6 +59,7 @@ async function getDevOverride(db, userCid, config, logger = null) {
                 enabled: false,
                 fakeCopiedPIs: [],
                 pretendToBePI: false,
+                impersonateCid: null,
                 lastUpdated: null,
                 wasAutoCreated: true
             };
@@ -70,6 +72,7 @@ async function getDevOverride(db, userCid, config, logger = null) {
             enabled: data.enabled === true,
             fakeCopiedPIs: data.fakeCopiedPIs || [],
             pretendToBePI: data.pretendToBePI === true,
+            impersonateCid: data.impersonateCid ? Number(data.impersonateCid) : null,
             lastUpdated: data.lastUpdated,
             wasAutoCreated: false
         };
@@ -154,7 +157,7 @@ async function hasUserCopiedWithDevOverride(db, userCid, piCid, config, logger)
  */
 async function setDevOverride(req, res, dependencies, config) {
     const { db, logger } = dependencies;
-    const { userCid, enabled, fakeCopiedPIs, pretendToBePI } = req.body;
+    const { userCid, enabled, fakeCopiedPIs, pretendToBePI, impersonateCid } = req.body;
     
     if (!userCid) {
         return res.status(400).json({ error: "Missing userCid" });
@@ -177,6 +180,17 @@ async function setDevOverride(req, res, dependencies, config) {
         });
     }
     
+    // Validate impersonateCid if provided
+    if (impersonateCid !== undefined && impersonateCid !== null) {
+        const parsedCid = Number(impersonateCid);
+        if (isNaN(parsedCid) || parsedCid <= 0) {
+            return res.status(400).json({ 
+                error: "Invalid request",
+                message: "impersonateCid must be a positive number, or null to disable impersonation"
+            });
+        }
+    }
+    
     // Ensure all CIDs are numbers
     const validatedPIs = enabled ? fakeCopiedPIs.map(cid => Number(cid)).filter(cid => !isNaN(cid) && cid > 0) : [];
     
@@ -193,12 +207,19 @@ async function setDevOverride(req, res, dependencies, config) {
             enabled: enabled !== undefined ? (enabled === true) : (existingData.enabled || false),
             fakeCopiedPIs: enabled !== undefined ? validatedPIs : (existingData.fakeCopiedPIs || []),
             pretendToBePI: pretendToBePI !== undefined ? (pretendToBePI === true) : (existingData.pretendToBePI || false),
+            impersonateCid: impersonateCid !== undefined ? (impersonateCid ? Number(impersonateCid) : null) : (existingData.impersonateCid || null),
             lastUpdated: FieldValue.serverTimestamp()
         };
         
         await overrideRef.set(overrideData, { merge: true });
         
-        logger.log('SUCCESS', `[setDevOverride] Updated dev override for user ${userCid}: enabled=${overrideData.enabled}, pretendToBePI=${overrideData.pretendToBePI}, ${validatedPIs.length} fake PIs`);
+        const logParts = [
+            `enabled=${overrideData.enabled}`,
+            `pretendToBePI=${overrideData.pretendToBePI}`,
+            `impersonateCid=${overrideData.impersonateCid || 'null'}`,
+            `${validatedPIs.length} fake PIs`
+        ];
+        logger.log('SUCCESS', `[setDevOverride] Updated dev override for user ${userCid}: ${logParts.join(', ')}`);
         
         return res.status(200).json({
             success: true,
@@ -248,6 +269,7 @@ async function getDevOverrideStatus(req, res, dependencies, config) {
             enabled: devOverride.enabled,
             fakeCopiedPIs: devOverride.fakeCopiedPIs,
             pretendToBePI: devOverride.pretendToBePI || false,
+            impersonateCid: devOverride.impersonateCid || null,
             lastUpdated: devOverride.lastUpdated,
             wasAutoCreated: devOverride.wasAutoCreated || false
         });
@@ -258,12 +280,36 @@ async function getDevOverrideStatus(req, res, dependencies, config) {
     }
 }
 
+/**
+ * Get the effective CID to use for a developer account
+ * Returns impersonateCid if set, otherwise returns the actual userCid
+ * Only works for developer accounts
+ */
+async function getEffectiveCid(db, userCid, config, logger = null) {
+    if (!isDeveloperAccount(userCid)) {
+        return Number(userCid); // Not a developer, return actual CID
+    }
+    
+    const devOverride = await getDevOverride(db, userCid, config, logger);
+    if (devOverride && devOverride.impersonateCid) {
+        if (logger && logger.log) {
+            logger.log('INFO', `[getEffectiveCid] DEV OVERRIDE: User ${userCid} impersonating CID ${devOverride.impersonateCid}`);
+        } else {
+            console.log(`[getEffectiveCid] DEV OVERRIDE: User ${userCid} impersonating CID ${devOverride.impersonateCid}`);
+        }
+        return Number(devOverride.impersonateCid);
+    }
+    
+    return Number(userCid);
+}
+
 module.exports = {
     isDeveloperAccount,
     getDevOverride,
     getCopiedPIsWithDevOverride,
     hasUserCopiedWithDevOverride,
     setDevOverride,
-    getDevOverrideStatus
+    getDevOverrideStatus,
+    getEffectiveCid
 };
 

package/package.json

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