bulltrackers-module 1.0.541 → 1.0.543

package/functions/computation-system/executors/StandardExecutor.js

@@ -274,7 +274,8 @@ class StandardExecutor {
         const targetUserType = metadata.userType; 
         // [NEW] Always load Global Helpers
         const mappings = await loader.loadMappings();
-        const piMasterList = await loader.loadPopularInvestorMasterList(config, deps); // [NEW] Loaded globally
+        // [FIX] Correct method name: loadPIMasterList (not loadPopularInvestorMasterList)
+        const piMasterList = await loader.loadPIMasterList(); 
         const SCHEMAS = mathLayer.SCHEMAS;
 
         // 1. Load Root Data

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

@@ -346,6 +346,86 @@ async function getPiFetchStatus(req, res, dependencies, config) {
                 }
             }
             
+            // Check if request is stale (stuck in processing state for too long)
+            // Set to 2 minutes to prevent indefinite polling when computation system crashes
+            const { FieldValue } = require('@google-cloud/firestore');
+            const STALE_THRESHOLD_MS = 2 * 60 * 1000; // 2 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 startedAt = latestRequest.startedAt?.toDate?.()?.getTime() || 
+                                 latestRequest.startedAt?.toMillis?.() || null;
+                const updatedAt = latestRequest.updatedAt?.toDate?.()?.getTime() || 
+                                 latestRequest.updatedAt?.toMillis?.() || null;
+                
+                // Use the most recent timestamp to determine age
+                const referenceTime = startedAt || dispatchedAt || createdAt || updatedAt;
+                
+                if (referenceTime && (now - referenceTime) > STALE_THRESHOLD_MS) {
+                    // Before marking as stale, do one final check for computation results
+                    const finalCheckDate = new Date();
+                    let foundResults = false;
+                    for (let i = 0; i < 2; i++) {
+                        const dateStr = new Date(finalCheckDate);
+                        dateStr.setDate(finalCheckDate.getDate() - i);
+                        const dateStrFormatted = dateStr.toISOString().split('T')[0];
+                        
+                        const docRef = db.collection(insightsCollection)
+                            .doc(dateStrFormatted)
+                            .collection(resultsSub)
+                            .doc('popular-investor')
+                            .collection(compsSub)
+                            .doc('PopularInvestorProfileMetrics');
+                        
+                        const doc = await docRef.get();
+                        if (doc.exists) {
+                            const { tryDecompress } = require('../data_helpers');
+                            const data = tryDecompress(doc.data());
+                            if (data && typeof data === 'object' && data[String(piCidNum)]) {
+                                foundResults = true;
+                                status = 'completed';
+                                await requestsSnapshot.docs[0].ref.update({
+                                    status: 'completed',
+                                    completedAt: FieldValue.serverTimestamp(),
+                                    updatedAt: FieldValue.serverTimestamp()
+                                });
+                                logger.log('INFO', `[getPiFetchStatus] Found computation results on stale check, marked as completed`);
+                                break;
+                            }
+                        }
+                    }
+                    
+                    if (!foundResults) {
+                        isStale = true;
+                        logger.log('WARN', `[getPiFetchStatus] Detected stale request ${latestRequest.requestId} for PI ${piCidNum}. 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', `[getPiFetchStatus] Marked stale request ${latestRequest.requestId} as failed`);
+                } catch (updateErr) {
+                    logger.log('WARN', `[getPiFetchStatus] Failed to update stale request status`, updateErr);
+                }
+            }
+            
             const response = {
                 success: true,
                 dataAvailable: status === 'completed',
@@ -360,8 +440,11 @@ async function getPiFetchStatus(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 computing

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

@@ -319,8 +319,8 @@ async function getUserSyncStatus(req, res, dependencies, config) {
             }
             
             // Check if request is stale (stuck in processing state for too long)
-            // Increased timeout to 15 minutes to account for computation time
-            const STALE_THRESHOLD_MS = 15 * 60 * 1000; // 15 minutes
+            // Set to 2 minutes to prevent indefinite polling when computation system crashes
+            const STALE_THRESHOLD_MS = 2 * 60 * 1000; // 2 minutes
             const processingStates = ['processing', 'dispatched', 'indexing', 'computing', 'queued'];
             const isProcessingState = processingStates.includes(status);
             

package/package.json

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