bulltrackers-module 1.0.453 → 1.0.455

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

@@ -735,30 +735,42 @@ async function getUserSocialPosts(req, res, dependencies, config) {
 
 /**
  * GET /user/me/instrument-mappings
- * Fetches instrument ID to ticker mapping for the frontend
+ * 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 = await db.collection('instrument_mappings').doc('etoro_to_ticker').get();
+        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,
-            count: Object.keys(idToTicker).length
+            instrumentToSector: idToSector,
+            count: Object.keys(idToTicker).length,
+            sectorCount: Object.keys(idToSector).length
         });
 
     } catch (error) {
@@ -1847,11 +1859,16 @@ async function getPiProfile(req, res, dependencies, config) {
             });
         }
         
+        // 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,

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

@@ -234,6 +234,47 @@ async function getUserSyncStatus(req, res, dependencies, config) {
             const latestRequest = requestsSnapshot.docs[0].data();
             let status = latestRequest.status || 'queued';
             
+            // Check if request is stale (stuck in processing state for too long)
+            const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+            const processingStates = ['processing', 'dispatched', 'indexing', 'computing', 'queued'];
+            const isProcessingState = processingStates.includes(status);
+            
+            let isStale = false;
+            if (isProcessingState) {
+                const now = Date.now();
+                const createdAt = latestRequest.createdAt?.toDate?.()?.getTime() || 
+                                 latestRequest.createdAt?.toMillis?.() || null;
+                const dispatchedAt = latestRequest.dispatchedAt?.toDate?.()?.getTime() || 
+                                    latestRequest.dispatchedAt?.toMillis?.() || null;
+                const updatedAt = latestRequest.updatedAt?.toDate?.()?.getTime() || 
+                                 latestRequest.updatedAt?.toMillis?.() || null;
+                
+                // Use the most recent timestamp to determine age
+                const referenceTime = dispatchedAt || createdAt || updatedAt;
+                
+                if (referenceTime && (now - referenceTime) > STALE_THRESHOLD_MS) {
+                    isStale = true;
+                    logger.log('WARN', `[getUserSyncStatus] Detected stale request ${latestRequest.requestId} for user ${targetCidNum}. Status: ${status}, Age: ${Math.round((now - referenceTime) / 60000)} minutes`);
+                }
+            }
+            
+            // If stale, mark as failed to stop polling
+            if (isStale) {
+                status = 'failed';
+                const requestDocRef = requestsSnapshot.docs[0].ref;
+                try {
+                    await requestDocRef.update({
+                        status: 'failed',
+                        error: 'Request timed out - task may have failed to process. Please try again.',
+                        failedAt: FieldValue.serverTimestamp(),
+                        updatedAt: FieldValue.serverTimestamp()
+                    });
+                    logger.log('INFO', `[getUserSyncStatus] Marked stale request ${latestRequest.requestId} as failed`);
+                } catch (updateErr) {
+                    logger.log('WARN', `[getUserSyncStatus] Failed to update stale request status`, updateErr);
+                }
+            }
+            
             const response = {
                 success: true,
                 status,
@@ -249,8 +290,11 @@ async function getUserSyncStatus(req, res, dependencies, config) {
             
             // Include error details if status is failed
             if (status === 'failed') {
-                response.error = latestRequest.error || 'Unknown error occurred';
-                response.failedAt = latestRequest.failedAt?.toDate?.()?.toISOString() || null;
+                response.error = isStale 
+                    ? 'Request timed out - task may have failed to process. Please try again.'
+                    : (latestRequest.error || 'Unknown error occurred');
+                response.failedAt = latestRequest.failedAt?.toDate?.()?.toISOString() || 
+                                   (isStale ? new Date().toISOString() : null);
             }
             
             // Include raw data status if processing

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

@@ -646,7 +646,7 @@ async function handleOnDemandUserUpdate(taskData, config, dependencies) {
 
         logger.log('SUCCESS', `[On-Demand Update] Complete for ${username}`);
         
-        // Update request status to completed if this is a sync request
+        // Update request status and trigger computation if this is a sync request
         if (requestId && source === 'on_demand_sync' && db) {
             try {
                 const requestRef = db.collection('user_sync_requests')
@@ -654,14 +654,87 @@ async function handleOnDemandUserUpdate(taskData, config, dependencies) {
                     .collection('requests')
                     .doc(requestId);
                 
-                await requestRef.update({
-                    status: 'completed',
-                    completedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp(),
-                    updatedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp()
-                });
-                logger.log('INFO', `[On-Demand Update] Updated sync request ${requestId} to completed`);
+                // CRITICAL: Trigger root data indexer FIRST so computation system knows data exists
+                try {
+                    const { runRootDataIndexer } = require('../../root-data-indexer/index');
+                    
+                    // Get rootDataIndexer config from injected config object
+                    const rootDataIndexerConfig = config.rootDataIndexer || {};
+                    
+                    // Build indexer config with targetDate for single-date indexing
+                    const indexerConfig = {
+                        ...rootDataIndexerConfig, // Use injected config (has all collection names)
+                        targetDate: today // Index only today's date for speed
+                    };
+                    
+                    logger.log('INFO', `[On-Demand Update] Triggering root data indexer for date ${today} before computation...`);
+                    await runRootDataIndexer(indexerConfig, dependencies);
+                    logger.log('INFO', `[On-Demand Update] Root data indexer completed for date ${today}`);
+                    
+                    // Update status to indicate indexing is done, computation is being triggered
+                    await requestRef.update({
+                        status: 'computing',
+                        indexedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp(),
+                        updatedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp()
+                    });
+                } catch (indexerError) {
+                    logger.log('ERROR', `[On-Demand Update] Failed to run root data indexer for ${today}`, indexerError);
+                    // Continue anyway - computation might still work if index already exists
+                    // But update status to indicate we tried
+                    await requestRef.update({
+                        status: 'computing',
+                        indexerError: indexerError.message,
+                        updatedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp()
+                    });
+                }
+                
+                // Trigger computation for SignedInUserProfileMetrics
+                const { pubsub } = dependencies;
+                if (pubsub) {
+                    const computationTopic = config.computationSystem?.computationTopicStandard || 'computation-tasks';
+                    const topic = pubsub.topic(computationTopic);
+                    const crypto = require('crypto');
+                    
+                    const computationMessage = {
+                        action: 'RUN_COMPUTATION_DATE',
+                        computation: 'SignedInUserProfileMetrics',
+                        date: today,
+                        pass: '1', // Standard pass
+                        dispatchId: crypto.randomUUID(),
+                        triggerReason: 'on_demand_sync',
+                        resources: 'standard',
+                        metadata: {
+                            onDemand: true,
+                            requestId: requestId,
+                            userCid: cid,
+                            username: username
+                        },
+                        traceContext: {
+                            traceId: crypto.randomBytes(16).toString('hex'),
+                            spanId: crypto.randomBytes(8).toString('hex'),
+                            sampled: true
+                        }
+                    };
+                    
+                    await topic.publishMessage({
+                        data: Buffer.from(JSON.stringify(computationMessage))
+                    });
+                    
+                    logger.log('INFO', `[On-Demand Update] Triggered computation SignedInUserProfileMetrics for user ${cid} (${username}) for date ${today}`);
+                    
+                    // Don't mark as completed yet - wait for computation to finish
+                    // The status will remain 'computing' until computation completes
+                } else {
+                    logger.log('WARN', `[On-Demand Update] PubSub not available, cannot trigger computation`);
+                    // Mark as completed if we can't trigger computation
+                    await requestRef.update({
+                        status: 'completed',
+                        completedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp(),
+                        updatedAt: require('@google-cloud/firestore').FieldValue.serverTimestamp()
+                    });
+                }
             } catch (err) {
-                logger.log('WARN', `[On-Demand Update] Failed to update request status to completed for ${requestId}`, err);
+                logger.log('WARN', `[On-Demand Update] Failed to update request status or trigger computation for ${requestId}`, err);
             }
         }
     } catch (error) {

package/package.json

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