bulltrackers-module 1.0.526 → 1.0.528

package/functions/computation-system/utils/data_loader.js

@@ -127,7 +127,7 @@ async function getPortfolioPartRefs(config, deps, dateString, requiredUserTypes
         }
     }
     
-    logger.log('INFO', `Found ${allPartRefs.length} total portfolio refs for ${dateString}`);
+    logger.log('INFO', `Found ${allPartRefs.length} total portfolio refs for ${dateString} for types: ${fetchAll ? 'ALL' : Array.from(types).join(',')}`);
     return allPartRefs;
 }
 

package/functions/fetch-popular-investors/helpers/fetch_helpers.js

@@ -2,9 +2,11 @@
  * @fileoverview Logic for fetching and storing Popular Investor rankings.
  * Integrates IntelligentProxyManager for IP rotation and IntelligentHeaderManager for 
  * user-agent/header rotation and performance tracking.
+ * UPDATED: Added compression support for large rankings data to avoid Firestore index limits.
  */
 const { IntelligentProxyManager } = require('../../core/utils/intelligent_proxy_manager');
 const { IntelligentHeaderManager } = require('../../core/utils/intelligent_header_manager');
+const zlib = require('zlib');
 
 /**
  * Fetches the top Popular Investors and stores the raw result in Firestore.
@@ -120,14 +122,56 @@ async function fetchAndStorePopularInvestors(config, dependencies) {
         try {
             const docRef = db.collection(finalRankingsCollectionName).doc(today);
             
-            await docRef.set({
+            // Prepare data for storage
+            const dataToStore = {
                 fetchedAt: new Date(),
                 totalRows: data.TotalRows,
                 itemsCount: data.Items.length,
                 ...data
-            });
+            };
+            
+            // Apply compression if data is large enough (similar to ResultCommitter pattern)
+            let firestorePayload;
+            try {
+                const jsonString = JSON.stringify(dataToStore);
+                const rawBuffer = Buffer.from(jsonString);
+                const SIZE_THRESHOLD = 50 * 1024; // 50KB threshold (same as ResultCommitter)
+                const MAX_COMPRESSED_SIZE = 900 * 1024; // 900KB max (Firestore limit is 1MB)
+                
+                if (rawBuffer.length > SIZE_THRESHOLD) {
+                    logger.log('INFO', `[PopularInvestorFetch] Rankings data size ${(rawBuffer.length / 1024).toFixed(2)}KB exceeds threshold. Compressing...`);
+                    
+                    // Gzip the JSON string
+                    const compressedBuffer = zlib.gzipSync(rawBuffer);
+                    
+                    if (compressedBuffer.length < MAX_COMPRESSED_SIZE) {
+                        // Create the compressed wrapper structure
+                        firestorePayload = {
+                            fetchedAt: new Date(), // Keep outer timestamp for indexing
+                            totalRows: data.TotalRows, // Keep outer metadata for indexing
+                            itemsCount: data.Items.length, // Keep outer metadata for indexing
+                            _compressed: true,
+                            payload: compressedBuffer
+                        };
+                        
+                        logger.log('INFO', `[PopularInvestorFetch] Compressed rankings data: ${(rawBuffer.length / 1024).toFixed(2)}KB -> ${(compressedBuffer.length / 1024).toFixed(2)}KB`);
+                    } else {
+                        // Compressed size still too large, store uncompressed (will need sharding in future)
+                        logger.log('WARN', `[PopularInvestorFetch] Compressed size ${(compressedBuffer.length / 1024).toFixed(2)}KB still exceeds limit. Storing uncompressed (may hit index limits).`);
+                        firestorePayload = dataToStore;
+                    }
+                } else {
+                    // Data is small enough, store uncompressed
+                    firestorePayload = dataToStore;
+                }
+            } catch (compressionError) {
+                logger.log('WARN', `[PopularInvestorFetch] Compression failed, storing uncompressed: ${compressionError.message}`);
+                firestorePayload = dataToStore;
+            }
+            
+            await docRef.set(firestorePayload);
 
-            logger.log('SUCCESS', `[PopularInvestorFetch] Stored ${data.TotalRows} rankings into ${finalRankingsCollectionName}/${today}`);
+            logger.log('SUCCESS', `[PopularInvestorFetch] Stored ${data.TotalRows} rankings into ${finalRankingsCollectionName}/${today}${firestorePayload._compressed ? ' (compressed)' : ''}`);
             
             // Update the master list of Popular Investors
             try {

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

@@ -187,7 +187,7 @@ function getLegacyPath(dataType, userCid, config = {}, params = {}, category = n
         // Popular Investor data (PI CID-based)
         piFetchRequests: `pi_fetch_requests/${piCid}/requests/${requestId}`,
         piFetchStatus: `pi_fetch_requests/${piCid}/global/latest`,
-        piUserFetchRequests: `pi_fetch_requests/${piCid}/user_requests/${cid}`,
+        piUserFetchRequests: `PopularInvestors/${piCid}/userFetchRequests/${cid}`,
         piReviews: `pi_reviews/${reviewId}`,
         piSocialPosts: `pi_social_posts/${piCid}/posts/${postId}`,
         piProfileViews: `profile_views/${piCid}_${date}`,

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

@@ -58,7 +58,10 @@ async function checkIfUserIsPI(db, userCid, config, logger = null) {
             return null;
         }
         
-        const rankingsData = rankingsDoc.data();
+        const rawRankingsData = rankingsDoc.data();
+        // Decompress if needed
+        const { tryDecompress } = require('../compression_helpers');
+        const rankingsData = tryDecompress(rawRankingsData);
         const rankingsItems = rankingsData.Items || [];
         
         // Find user in rankings

package/functions/generic-api/user-api/helpers/fetch/on_demand_fetch_helpers.js

@@ -108,9 +108,10 @@ async function requestPiFetch(req, res, dependencies, config) {
         });
         
         // Update user rate limit (use effective CID)
-        const userRequestRef = db.collection('pi_fetch_requests')
+        // Use new path: PopularInvestors/{piCid}/userFetchRequests/{userCid}
+        const userRequestRef = db.collection('PopularInvestors')
             .doc(String(piCidNum))
-            .collection('user_requests')
+            .collection('userFetchRequests')
             .doc(String(requestUserCid));
         
         await userRequestRef.set({
@@ -150,11 +151,13 @@ async function requestPiFetch(req, res, dependencies, config) {
             requestId,
             requestedBy: requestUserCid, // Use effective CID
             actualRequestedBy: Number(userCid), // Track actual developer CID
+            userType: 'POPULAR_INVESTOR', // Explicitly set userType for task engine
             metadata: {
                 onDemand: true,
                 targetCid: piCidNum, // Target specific user for optimization
                 requestedAt: now.toISOString(),
-                isImpersonating: isImpersonating || false
+                isImpersonating: isImpersonating || false,
+                userType: 'POPULAR_INVESTOR' // Also in metadata for consistency
             }
         };
         
@@ -421,10 +424,10 @@ async function getPiFetchStatus(req, res, dependencies, config) {
 async function checkRateLimits(db, userCid, piCid, logger) {
     const now = Date.now();
     
-    // Check user rate limit
-    const userRequestRef = db.collection('pi_fetch_requests')
+    // Check user rate limit - use new path: PopularInvestors/{piCid}/userFetchRequests/{userCid}
+    const userRequestRef = db.collection('PopularInvestors')
         .doc(String(piCid))
-        .collection('user_requests')
+        .collection('userFetchRequests')
         .doc(String(userCid));
     
     const userRequestDoc = await userRequestRef.get();
@@ -523,7 +526,9 @@ async function getPiUsername(db, piCid, config, logger) {
             return null;
         }
         
-        const rankingsData = rankingsDoc.data();
+        const rawRankingsData = rankingsDoc.data();
+        // Decompress if needed
+        const rankingsData = tryDecompress(rawRankingsData);
         const rankingsItems = rankingsData.Items || [];
         
         // Search for the PI in the rankings items

package/functions/generic-api/user-api/helpers/notifications/notification_helpers.js

@@ -162,6 +162,47 @@ async function sendOnDemandNotification(db, logger, userCid, type, title, messag
     }
 }
 
+/**
+ * Send progress notification during task engine processing
+ */
+async function notifyTaskEngineProgress(db, logger, requestingUserCid, requestId, username, stage, dataType = null, options = {}) {
+    if (!requestingUserCid) return; // No user to notify
+    
+    let title = 'Data Sync In Progress';
+    let message = `Syncing data for ${username}...`;
+    
+    if (stage === 'started') {
+        title = 'Data Sync Started';
+        message = `Started syncing data for ${username}. This may take a few minutes.`;
+    } else if (stage === 'portfolio_complete') {
+        title = 'Portfolio Data Synced';
+        message = `Portfolio data for ${username} has been fetched and stored.`;
+    } else if (stage === 'history_complete') {
+        title = 'Trade History Synced';
+        message = `Trade history for ${username} has been fetched and stored.`;
+    } else if (stage === 'social_complete') {
+        title = 'Social Posts Synced';
+        message = `Social posts for ${username} have been fetched and stored.`;
+    } else if (stage === 'indexing') {
+        title = 'Indexing Data';
+        message = `Indexing data for ${username}...`;
+    } else if (stage === 'computing') {
+        title = 'Computing Metrics';
+        message = `Computing metrics for ${username}...`;
+    }
+    
+    await sendOnDemandNotification(db, logger, requestingUserCid, 'progress', title, message, {
+        requestId,
+        username,
+        stage,
+        dataType,
+        notificationType: 'syncProcesses'
+    }, {
+        ...options,
+        notificationType: 'syncProcesses'
+    });
+}
+
 /**
  * Send notification when task engine completes data fetch
  */
@@ -172,15 +213,31 @@ async function notifyTaskEngineComplete(db, logger, requestingUserCid, requestId
     const title = success 
         ? 'Data Sync Complete' 
         : 'Data Sync Failed';
-    const message = success
-        ? `Your data sync for ${username} has completed. Portfolio, history, and social data have been stored.`
-        : (error || 'An error occurred while syncing your data. Please try again.');
+    
+    // Build a more detailed message based on what succeeded
+    let message = '';
+    if (success && typeof success === 'object') {
+        const completed = [];
+        if (success.portfolio) completed.push('portfolio');
+        if (success.history) completed.push('trade history');
+        if (success.social) completed.push('social posts');
+        
+        if (completed.length > 0) {
+            message = `Your data sync for ${username} has completed. ${completed.join(', ')} data ${completed.length === 1 ? 'has' : 'have'} been stored.`;
+        } else {
+            message = `Your data sync for ${username} has completed, but no data was stored.`;
+        }
+    } else if (success) {
+        message = `Your data sync for ${username} has completed. Portfolio, history, and social data have been stored.`;
+    } else {
+        message = error || 'An error occurred while syncing your data. Please try again.';
+    }
     
     await sendOnDemandNotification(db, logger, requestingUserCid, type, title, message, {
         requestId,
         username,
         stage: 'task_engine',
-        success,
+        success: typeof success === 'object' ? success : { portfolio: success, history: success, social: success },
         notificationType: 'syncProcesses'
     }, {
         ...options,
@@ -482,6 +539,7 @@ async function getNotificationHistory(req, res, dependencies, config) {
 
 module.exports = {
     sendOnDemandNotification,
+    notifyTaskEngineProgress,
     notifyTaskEngineComplete,
     notifyComputationComplete,
     notifyPIDataRefreshed,

package/functions/generic-api/user-api/helpers/search/pi_request_helpers.js

@@ -244,7 +244,10 @@ async function checkPisInRankingsLegacy(db, items, config, logger) {
             };
         }
         
-        const rankingsData = rankingsDoc.data();
+        const rawRankingsData = rankingsDoc.data();
+        // Decompress if needed
+        const { tryDecompress } = require('../core/compression_helpers');
+        const rankingsData = tryDecompress(rawRankingsData);
         const rankingsItems = rankingsData.Items || [];
         
         // Create a set of CIDs that exist in rankings

package/functions/generic-api/user-api/helpers/search/pi_search_helpers.js

@@ -4,6 +4,7 @@
  */
 
 const { findLatestRankingsDate } = require('../core/data_lookup_helpers');
+const { tryDecompress } = require('../core/compression_helpers');
 
 /**
  * GET /user/search/pis
@@ -32,7 +33,9 @@ async function searchPopularInvestors(req, res, dependencies, config) {
             return res.status(404).json({ error: "Rankings data not available" });
         }
         
-        const rankingsData = rankingsDoc.data();
+        const rawRankingsData = rankingsDoc.data();
+        // Decompress if needed
+        const rankingsData = tryDecompress(rawRankingsData);
         const rankingsItems = rankingsData.Items || [];
         
         // Search by username (case-insensitive, partial match)

package/functions/generic-api/user-api/helpers/watchlist/watchlist_generation_helpers.js

@@ -161,7 +161,10 @@ async function autoGenerateWatchlist(req, res, dependencies, config) {
             return res.status(404).json({ error: "Rankings data not available" });
         }
         
-        const rankingsData = rankingsDoc.data();
+        const rawRankingsData = rankingsDoc.data();
+        // Decompress if needed
+        const { tryDecompress } = require('../core/compression_helpers');
+        const rankingsData = tryDecompress(rawRankingsData);
         const rankingsItems = rankingsData.Items || [];
         const rankingsMap = new Map();
         for (const item of rankingsItems) {

package/functions/task-engine/helpers/data_storage_helpers.js

@@ -204,6 +204,21 @@ async function storePopularInvestorPortfolio({ db, logger, collectionRegistry, c
     
     await rootDataRef.set(portfolioDoc, { merge: false });
     
+    // 3. Store latest snapshot to user-centric collection (for fallback)
+    const { getCollectionPath } = collectionRegistry || {};
+    if (!getCollectionPath) {
+        throw new Error('collectionRegistry.getCollectionPath is required');
+    }
+    // Path: PopularInvestors/{cid}/portfolio/latest (4 segments)
+    const userLatestPath = getCollectionPath('popularInvestors', 'portfolio', { piCid: String(cid) });
+    const userLatestRef = db.doc(userLatestPath);
+    
+    await userLatestRef.set({
+        ...portfolioDoc,
+        date: date,
+        cid: String(cid)
+    }, { merge: false });
+    
     logger.log('INFO', `[DataStorage] Stored portfolio for PI ${cid} (date: ${date})`);
 }
 
@@ -219,7 +234,7 @@ async function storePopularInvestorPortfolio({ db, logger, collectionRegistry, c
  * @returns {Promise<void>}
  */
 async function storePopularInvestorTradeHistory({ db, logger, collectionRegistry, cid, date, historyData }) {
-    // Store to root data collection (for computations)
+    // 1. Store to root data collection (for computations)
     // Structure: PopularInvestorTradeHistoryData/{date}/{cid}/{cid}
     const rootDataRef = db.collection('PopularInvestorTradeHistoryData')
         .doc(date)
@@ -232,6 +247,22 @@ async function storePopularInvestorTradeHistory({ db, logger, collectionRegistry
         cid: String(cid)
     }, { merge: false });
     
+    // 2. Store latest snapshot to user-centric collection (for fallback)
+    const { getCollectionPath } = collectionRegistry || {};
+    if (!getCollectionPath) {
+        throw new Error('collectionRegistry.getCollectionPath is required');
+    }
+    // Path: PopularInvestors/{cid}/tradeHistory/latest (4 segments)
+    const userLatestPath = getCollectionPath('popularInvestors', 'tradeHistory', { piCid: String(cid) });
+    const userLatestRef = db.doc(userLatestPath);
+    
+    await userLatestRef.set({
+        ...historyData,
+        fetchedAt: FieldValue.serverTimestamp(),
+        date: date,
+        cid: String(cid)
+    }, { merge: false });
+    
     logger.log('INFO', `[DataStorage] Stored trade history for PI ${cid} (date: ${date})`);
 }
 
@@ -247,7 +278,7 @@ async function storePopularInvestorTradeHistory({ db, logger, collectionRegistry
  * @returns {Promise<void>}
  */
 async function storePopularInvestorSocialPosts({ db, logger, collectionRegistry, cid, date, posts }) {
-    // Store to root data collection (for computations)
+    // 1. Store to root data collection (for computations)
     // Structure: PopularInvestorSocialPostData/{date}/{cid}/{cid}
     const rootDataRef = db.collection('PopularInvestorSocialPostData')
         .doc(date)
@@ -268,6 +299,42 @@ async function storePopularInvestorSocialPosts({ db, logger, collectionRegistry,
         postCount: posts.length
     }, { merge: false });
     
+    // 2. Store latest posts to user-centric collection (for fallback)
+    const { getCollectionPath } = collectionRegistry || {};
+    if (!getCollectionPath) {
+        throw new Error('collectionRegistry.getCollectionPath is required');
+    }
+    const userPostsRef = db.collection(
+        getCollectionPath('popularInvestors', 'socialPosts', { piCid: String(cid) })
+    );
+    
+    // Store each post individually in user-centric collection
+    const batch = db.batch();
+    let batchCount = 0;
+    const MAX_BATCH_SIZE = 500;
+    
+    for (const post of posts) {
+        const postId = post.id || post.postId;
+        if (!postId) continue;
+        
+        const postRef = userPostsRef.doc(postId);
+        batch.set(postRef, {
+            ...post,
+            fetchedAt: FieldValue.serverTimestamp(),
+            date: date
+        }, { merge: false });
+        
+        batchCount++;
+        if (batchCount >= MAX_BATCH_SIZE) {
+            await batch.commit();
+            batchCount = 0;
+        }
+    }
+    
+    if (batchCount > 0) {
+        await batch.commit();
+    }
+    
     logger.log('INFO', `[DataStorage] Stored ${posts.length} social posts for PI ${cid} (date: ${date})`);
 }
 

package/functions/task-engine/helpers/popular_investor_helpers.js

@@ -7,7 +7,7 @@
 const crypto = require('crypto');
 const { shouldTryProxy, recordProxyOutcome, getFailureCount, getMaxFailures } = require('../utils/proxy_circuit_breaker');
 const { FieldValue } = require('@google-cloud/firestore');
-const { notifyTaskEngineComplete, notifyPIDataRefreshed } = require('../../generic-api/user-api/helpers/notifications/notification_helpers');
+const { notifyTaskEngineComplete, notifyTaskEngineProgress, notifyPIDataRefreshed } = require('../../generic-api/user-api/helpers/notifications/notification_helpers');
 const { conditionallyRunRootDataIndexer } = require('./root_data_indexer_helpers');
 
 const { 
@@ -164,6 +164,14 @@ async function handleGenericUserUpdate(taskData, config, dependencies, isPI) {
             const reqRef = db.collection(source === 'on_demand_sync' ? 'user_sync_requests' : 'pi_fetch_requests')
                            .doc(String(cid)).collection('requests').doc(requestId);
             await reqRef.update({ status: 'processing', startedAt: FieldValue.serverTimestamp() });
+            
+            // Send progress notification when task starts
+            if (metadata?.requestingUserCid) {
+                notifyTaskEngineProgress(db, logger, metadata.requestingUserCid, requestId, username, 'started', null, {
+                    collectionRegistry: dependencies.collectionRegistry,
+                    config
+                }).catch(() => {});
+            }
         } catch(e) {}
     }
 
@@ -173,15 +181,44 @@ async function handleGenericUserUpdate(taskData, config, dependencies, isPI) {
 
     try {
         // 2. Execute Fetches (Intelligent Skipping)
-        if (components.portfolio !== false) success.portfolio = await processPortfolio(context, config, runContext, isPI);
-        else logger.log('INFO', `[Update] Skipped Portfolio for ${username}`);
+        if (components.portfolio !== false) {
+            success.portfolio = await processPortfolio(context, config, runContext, isPI);
+            // Send progress notification after portfolio completes
+            if (requestId && metadata?.requestingUserCid && success.portfolio) {
+                notifyTaskEngineProgress(db, logger, metadata.requestingUserCid, requestId, username, 'portfolio_complete', 'portfolio', {
+                    collectionRegistry: dependencies.collectionRegistry,
+                    config
+                }).catch(() => {});
+            }
+        } else {
+            logger.log('INFO', `[Update] Skipped Portfolio for ${username}`);
+        }
 
-        if (components.tradeHistory !== false) success.history = await processHistory(context, config, runContext, isPI);
-        else logger.log('INFO', `[Update] Skipped History for ${username}`);
+        if (components.tradeHistory !== false) {
+            success.history = await processHistory(context, config, runContext, isPI);
+            // Send progress notification after history completes
+            if (requestId && metadata?.requestingUserCid && success.history) {
+                notifyTaskEngineProgress(db, logger, metadata.requestingUserCid, requestId, username, 'history_complete', 'tradeHistory', {
+                    collectionRegistry: dependencies.collectionRegistry,
+                    config
+                }).catch(() => {});
+            }
+        } else {
+            logger.log('INFO', `[Update] Skipped History for ${username}`);
+        }
 
         // Social is usually always fetched on updates unless explicitly disabled in data
         const includeSocial = taskData.data?.includeSocial !== false;
-        if (includeSocial) success.social = await processSocial(context, config, runContext, isPI);
+        if (includeSocial) {
+            success.social = await processSocial(context, config, runContext, isPI);
+            // Send progress notification after social completes
+            if (requestId && metadata?.requestingUserCid && success.social) {
+                notifyTaskEngineProgress(db, logger, metadata.requestingUserCid, requestId, username, 'social_complete', 'socialPosts', {
+                    collectionRegistry: dependencies.collectionRegistry,
+                    config
+                }).catch(() => {});
+            }
+        }
 
         // 3. Post-Processing (Notifications & Indexing)
         logger.log('SUCCESS', `[Update] Complete for ${username}. P:${success.portfolio} H:${success.history} S:${success.social}`);
@@ -239,49 +276,130 @@ async function finalizeOnDemandRequest(deps, config, taskData, isPI, success, to
                    .doc(String(cid)).collection('requests').doc(requestId);
     
     await reqRef.update({ status: 'indexing', rawDataStoredAt: FieldValue.serverTimestamp() });
+    
+    // Send progress notification for indexing
+    if (metadata?.requestingUserCid) {
+        notifyTaskEngineProgress(db, logger, metadata.requestingUserCid, requestId, username, 'indexing', null, {
+            collectionRegistry: deps.collectionRegistry,
+            config
+        }).catch(() => {});
+    }
 
     const dataTypes = [];
     if (success.portfolio) dataTypes.push(isPI ? 'piPortfolios' : 'signedInUserPortfolio');
     if (success.history) dataTypes.push(isPI ? 'piHistory' : 'signedInUserHistory');
     if (success.social) dataTypes.push(isPI ? 'piSocial' : 'signedInUserSocial');
 
+    // 1. Run Root Data Indexer and wait for completion
+    let indexerCompleted = false;
     try {
-        await conditionallyRunRootDataIndexer({
+        const indexerResult = await conditionallyRunRootDataIndexer({
             db, logger, dateStr: today,
             rootDataIndexerConfig: config.rootDataIndexer,
             dependencies: deps, counterRef: null, dataTypesRun: dataTypes
         });
-        await reqRef.update({ status: 'computing', indexedAt: FieldValue.serverTimestamp() });
+        
+        // indexerResult is true if it ran, false if skipped (already indexed)
+        // Both cases mean the indexer is "complete" for our purposes
+        indexerCompleted = true;
+        logger.log('INFO', `[On-Demand] Root data indexer ${indexerResult ? 'completed' : 'skipped (already indexed)'} for ${today}`);
+        
+        await reqRef.update({ 
+            status: 'computing', 
+            indexedAt: FieldValue.serverTimestamp(),
+            indexerCompleted: true,
+            indexerRan: indexerResult
+        });
+        
+        // Send progress notification for computing
+        if (metadata?.requestingUserCid) {
+            notifyTaskEngineProgress(db, logger, metadata.requestingUserCid, requestId, username, 'computing', null, {
+                collectionRegistry: deps.collectionRegistry,
+                config
+            }).catch(() => {});
+        }
     } catch (e) {
-        logger.log('ERROR', `[Indexer] Failed: ${e.message}`);
-        await reqRef.update({ indexerError: e.message }); // Continue to computation anyway
+        logger.log('ERROR', `[On-Demand] Root data indexer failed: ${e.message}`);
+        await reqRef.update({ 
+            status: 'indexer_failed', 
+            indexerError: e.message,
+            indexerFailedAt: FieldValue.serverTimestamp()
+        });
+        // Don't continue to computation if indexer failed - data might not be properly indexed
+        // Log error but don't throw - we'll skip computations and let the function complete
+        logger.log('WARN', `[On-Demand] Skipping computation trigger due to indexer failure`);
+        indexerCompleted = false;
     }
 
-    // 2. Trigger Computations
-    if (pubsub && config.computationSystem) {
+    // 2. Trigger Computations (only if root data indexer completed successfully)
+    if (indexerCompleted && pubsub && config.computationSystem) {
         const { triggerComputationWithDependencies } = require('../../computation-system/helpers/on_demand_helpers');
-        const comps = isPI 
-            ? ['PopularInvestorProfileMetrics'] 
-            : ['SignedInUserProfileMetrics', 'SignedInUserCopiedList', 'SignedInUserCopiedPIs', 'SignedInUserPastCopies'];
         
-        // PIs might also be users
-        if (isPI) {
-             const userDoc = await db.collection('signed_in_users').doc(String(cid)).get();
-             if (userDoc.exists) comps.push('SignedInUserPIPersonalizedMetrics');
+        // Use userType from metadata if available, otherwise fall back to isPI
+        const userType = metadata?.userType || (isPI ? 'POPULAR_INVESTOR' : 'SIGNED_IN_USER');
+        
+        // Determine which computations to run based on userType
+        const comps = [];
+        if (userType === 'POPULAR_INVESTOR') {
+            comps.push('PopularInvestorProfileMetrics');
+            // PIs might also be signed-in users
+            const userDoc = await db.collection('signed_in_users').doc(String(cid)).get();
+            if (userDoc.exists) {
+                comps.push('SignedInUserPIPersonalizedMetrics');
+            }
+        } else if (userType === 'SIGNED_IN_USER') {
+            comps.push('SignedInUserProfileMetrics', 'SignedInUserCopiedList', 'SignedInUserCopiedPIs', 'SignedInUserPastCopies');
+        } else {
+            // Fallback to isPI-based logic for backward compatibility
+            if (isPI) {
+                comps.push('PopularInvestorProfileMetrics');
+                const userDoc = await db.collection('signed_in_users').doc(String(cid)).get();
+                if (userDoc.exists) comps.push('SignedInUserPIPersonalizedMetrics');
+            } else {
+                comps.push('SignedInUserProfileMetrics', 'SignedInUserCopiedList', 'SignedInUserCopiedPIs', 'SignedInUserPastCopies');
+            }
         }
 
+        logger.log('INFO', `[On-Demand] Triggering ${comps.length} computations for ${userType} (${username}): ${comps.join(', ')}`);
+
         for (const comp of comps) {
-            await triggerComputationWithDependencies(comp, today, deps, config.computationSystem, {
-                triggerReason: source, requestId, userCid: cid, username, onDemand: true,
-                requestingUserCid: metadata?.requestingUserCid
-            });
+            try {
+                await triggerComputationWithDependencies(comp, today, deps, config.computationSystem, {
+                    triggerReason: source, 
+                    requestId, 
+                    userCid: cid, 
+                    username, 
+                    onDemand: true,
+                    requestingUserCid: metadata?.requestingUserCid,
+                    userType: userType // Pass userType explicitly
+                });
+                logger.log('INFO', `[On-Demand] Triggered computation: ${comp} for ${today}`);
+            } catch (compError) {
+                logger.log('ERROR', `[On-Demand] Failed to trigger computation ${comp}: ${compError.message}`);
+                // Continue with other computations even if one fails
+            }
         }
+        
+        // Update request status to indicate computations were triggered
+        await reqRef.update({ 
+            computationsTriggered: true,
+            computationsTriggeredAt: FieldValue.serverTimestamp(),
+            triggeredComputations: comps
+        });
+    } else if (!indexerCompleted) {
+        logger.log('WARN', `[On-Demand] Skipping computation trigger - root data indexer did not complete`);
+    } else if (!pubsub || !config.computationSystem) {
+        logger.log('WARN', `[On-Demand] Skipping computation trigger - pubsub or computationSystem config missing`);
     }
 
-    // 3. Notify User (if applicable)
+    // 3. Notify User (if applicable) - Send success notification with detailed status
     if (metadata?.requestingUserCid) {
-        const anySuccess = success.portfolio || success.history;
-        notifyTaskEngineComplete(db, logger, metadata.requestingUserCid, requestId, username, anySuccess, anySuccess ? null : "Data fetch failed").catch(()=>{});
+        // Check all data types for accurate success status
+        const anySuccess = success.portfolio || success.history || success.social;
+        notifyTaskEngineComplete(db, logger, metadata.requestingUserCid, requestId, username, success, anySuccess ? null : "Data fetch failed", {
+            collectionRegistry: deps.collectionRegistry,
+            config
+        }).catch(()=>{});
     }
 }
 

package/package.json

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