bulltrackers-module 1.0.629 → 1.0.631

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

@@ -1,677 +0,0 @@
-/**
- * @fileoverview User Sync Request Helpers
- * Allows users to request on-demand sync for their own profile or Popular Investor profiles
- * Rate limiting: 1 update per user per 6 hours (global, not per-requester)
- * Developer accounts bypass rate limits
- */
-
-const { FieldValue } = require('@google-cloud/firestore');
-const crypto = require('crypto');
-
-const RATE_LIMIT_HOURS = 6;
-const RATE_LIMIT_MS = RATE_LIMIT_HOURS * 60 * 60 * 1000;
-
-/**
- * Request on-demand sync for a user (signed-in user or Popular Investor)
- * POST /user/:userCid/sync
- */
-async function requestUserSync(req, res, dependencies, config) {
-    const { db, logger, pubsub } = dependencies;
-    const { userCid: targetUserCid } = req.params;
-    
-    // Get requesting userCid from query
-    const requestingUserCid = req.query?.userCid;
-    
-    if (!requestingUserCid) {
-        return res.status(400).json({ 
-            success: false,
-            error: "Missing userCid",
-            message: "Please provide userCid as a query parameter"
-        });
-    }
-    
-    // Check the referrer or source header to determine if this is from PI page or profile page
-    const referrer = req.headers.referer || req.headers.referrer || '';
-    const sourcePage = req.query?.sourcePage || req.body?.sourcePage || '';
-    
-    // Determine user type based on where the request came from
-    // If from /popular-investors/{cid}, it's a PI
-    // If from /profile, it's a signed-in user
-    const isPI = referrer.includes('/popular-investors/') || sourcePage === 'popular-investor';
-    
-    // Check for dev override impersonation
-    const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
-    const effectiveCid = await getEffectiveCid(db, requestingUserCid, config, logger);
-    const devOverride = await getDevOverride(db, requestingUserCid, config, logger);
-    const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(requestingUserCid);
-    
-    const targetCidNum = Number(targetUserCid);
-    if (isNaN(targetCidNum) || targetCidNum <= 0) {
-        return res.status(400).json({
-            success: false,
-            error: "Invalid user CID",
-            message: "Please provide a valid user CID"
-        });
-    }
-    
-    try {
-        // Check if this is a developer account (bypass rate limits for developers)
-        const { isDeveloperAccount } = require('../dev/dev_helpers');
-        const isDeveloper = isDeveloperAccount(requestingUserCid);
-        
-        let rateLimitCheck = { allowed: true }; // Default to allowed for developers
-        
-        if (!isDeveloper) {
-            // Check global rate limit (applies to target user, not requester)
-            rateLimitCheck = await checkRateLimits(db, targetCidNum, logger);
-            
-            if (!rateLimitCheck.allowed) {
-                return res.status(429).json({
-                    success: false,
-                    error: "Rate limit exceeded",
-                    message: rateLimitCheck.message,
-                    rateLimit: {
-                        canRequestAgainAt: rateLimitCheck.canRequestAgainAt,
-                        lastRequestedAt: rateLimitCheck.lastRequestedAt
-                    }
-                });
-            }
-        } else {
-            logger.log('INFO', `[requestUserSync] Developer account ${requestingUserCid} bypassing rate limits${isImpersonating ? ` (impersonating ${effectiveCid})` : ''}`);
-        }
-        
-        // Get username based on user type
-        let username = null;
-        if (isPI) {
-            // For PIs, get username from rankings
-            const { checkIfUserIsPI } = require('../core/user_status_helpers');
-            const rankEntry = await checkIfUserIsPI(db, targetCidNum, config, logger);
-            if (rankEntry && (rankEntry.UserName || rankEntry.username)) {
-                username = rankEntry.UserName || rankEntry.username;
-            }
-        } else {
-            // For signed-in users, try verification data
-            const signedInUsersCollection = config.signedInUsersCollection || 'signed_in_users';
-            const userDoc = await db.collection(signedInUsersCollection).doc(String(targetCidNum)).get();
-            if (userDoc.exists) {
-                const userData = userDoc.data();
-                username = userData.username || userData.verification?.username || null;
-            }
-        }
-        
-        if (!username) {
-            username = String(targetCidNum); // Fallback to CID
-        }
-        
-        // Create request document
-        const requestId = `sync_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-        const now = new Date();
-        
-        // Store request
-        const requestRef = db.collection('user_sync_requests')
-            .doc(String(targetCidNum))
-            .collection('requests')
-            .doc(requestId);
-        
-        await requestRef.set({
-            requestId,
-            targetUserCid: targetCidNum,
-            requestedBy: Number(requestingUserCid),
-            effectiveRequestedBy: effectiveCid,
-            username,
-            userType: isPI ? 'POPULAR_INVESTOR' : 'SIGNED_IN_USER',
-            status: 'queued',
-            isImpersonating: isImpersonating || false,
-            createdAt: FieldValue.serverTimestamp(),
-            updatedAt: FieldValue.serverTimestamp()
-        });
-        
-        // Update global rate limit (for target user)
-        const globalRef = db.collection('user_sync_requests')
-            .doc(String(targetCidNum))
-            .collection('global')
-            .doc('latest');
-        
-        await globalRef.set({
-            targetUserCid: targetCidNum,
-            lastRequestedAt: FieldValue.serverTimestamp(),
-            lastRequestedBy: Number(requestingUserCid),
-            totalRequests: FieldValue.increment(1),
-            updatedAt: FieldValue.serverTimestamp()
-        }, { merge: true });
-        
-        // Publish to task engine - use on-demand topic for API requests
-        const topicName = config.taskEngine?.PUBSUB_TOPIC_USER_FETCH_ONDEMAND || 
-                         config.pubsubTopicUserFetchOnDemand || 
-                         'etoro-user-fetch-topic-ondemand';
-        const topic = pubsub.topic(topicName);
-        
-        const message = {
-            type: isPI ? 'POPULAR_INVESTOR_UPDATE' : 'ON_DEMAND_USER_UPDATE',
-            cid: targetCidNum,
-            username: username,
-            priority: 'high',
-            source: 'on_demand_sync',
-            requestId,
-            requestedBy: Number(requestingUserCid),
-            effectiveRequestedBy: effectiveCid,
-            data: {
-                includeSocial: true, // Always include social data for on-demand syncs
-                since: new Date(Date.now() - (7 * 24 * 60 * 60 * 1000)).toISOString() // Last 7 days
-            },
-            metadata: {
-                onDemand: true,
-                targetCid: targetCidNum, // Target specific user for optimization
-                requestedAt: now.toISOString(),
-                isImpersonating: isImpersonating || false,
-                requestingUserCid: Number(requestingUserCid), // Store for notifications
-                userType: isPI ? 'POPULAR_INVESTOR' : 'SIGNED_IN_USER' // Explicitly set userType in metadata
-            }
-        };
-        
-        const messageId = await topic.publishMessage({
-            data: Buffer.from(JSON.stringify(message))
-        });
-        
-        // Update request with message ID
-        await requestRef.update({
-            taskMessageId: messageId,
-            status: 'dispatched',
-            dispatchedAt: FieldValue.serverTimestamp(),
-            updatedAt: FieldValue.serverTimestamp()
-        });
-        
-        logger.log('INFO', `[requestUserSync] User ${requestingUserCid}${isImpersonating ? ` (impersonating ${effectiveCid})` : ''} requested sync for ${isPI ? 'PI' : 'signed-in user'} ${targetCidNum} (${username}). Request ID: ${requestId}`);
-        
-        return res.status(200).json({
-            success: true,
-            requestId,
-            status: 'dispatched',
-            message: 'Sync request queued successfully. Data will be updated shortly.',
-            estimatedTime: '2-5 minutes',
-            rateLimit: {
-                canRequestAgainAt: new Date(Date.now() + RATE_LIMIT_MS).toISOString()
-            }
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[requestUserSync] Error requesting sync for user ${targetCidNum}`, error);
-        return res.status(500).json({
-            success: false,
-            error: "Internal server error",
-            message: error.message
-        });
-    }
-}
-
-/**
- * Get sync status for a user
- * GET /user/:userCid/sync-status
- */
-async function getUserSyncStatus(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid: targetUserCid } = req.params;
-    const requestingUserCid = req.query?.userCid; // Optional - for rate limit info
-    
-    const targetCidNum = Number(targetUserCid);
-    if (isNaN(targetCidNum) || targetCidNum <= 0) {
-        return res.status(400).json({
-            success: false,
-            error: "Invalid user CID"
-        });
-    }
-    
-    try {
-        // Check for latest request
-        const requestsRef = db.collection('user_sync_requests')
-            .doc(String(targetCidNum))
-            .collection('requests')
-            .orderBy('createdAt', 'desc')
-            .limit(1);
-        
-        const requestsSnapshot = await requestsRef.get();
-        
-        if (!requestsSnapshot.empty) {
-            const latestRequest = requestsSnapshot.docs[0].data();
-            let status = latestRequest.status || 'queued';
-            const userType = latestRequest.userType || 'SIGNED_IN_USER'; // Default to signed-in user
-            
-            // If status is 'indexing' or 'computing', check if computation results are now available
-            if (status === 'indexing' || status === 'computing') {
-                const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-                const resultsSub = config.resultsSubcollection || 'results';
-                const compsSub = config.computationsSubcollection || 'computations';
-                
-                // Determine category and computation name based on user type
-                // 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
-                let category, computationName;
-                if (userType === 'POPULAR_INVESTOR') {
-                    category = 'popular-investor';
-                    computationName = 'PopularInvestorProfileMetrics';
-                } else {
-                    // SignedInUserProfileMetrics is in popular-investor folder, so stored in popular-investor category
-                    category = 'popular-investor';
-                    computationName = 'SignedInUserProfileMetrics';
-                }
-                
-                // Check today and yesterday for computation results
-                const checkDate = new Date();
-                for (let i = 0; i < 2; i++) {
-                    const dateStr = new Date(checkDate);
-                    dateStr.setDate(checkDate.getDate() - i);
-                    const dateStrFormatted = dateStr.toISOString().split('T')[0];
-                    
-                    const docRef = db.collection(insightsCollection)
-                        .doc(dateStrFormatted)
-                        .collection(resultsSub)
-                        .doc(category)
-                        .collection(compsSub)
-                        .doc(computationName);
-                    
-                    const doc = await docRef.get();
-                    if (doc.exists) {
-                        const docData = doc.data();
-                        let mergedData = null;
-                        
-                        // Check if data is sharded
-                        if (docData._sharded === true && docData._shardCount) {
-                            // Data is stored in shards - read all shards and merge
-                            const shardsCol = docRef.collection('_shards');
-                            const shardsSnapshot = await shardsCol.get();
-                            
-                            if (!shardsSnapshot.empty) {
-                                mergedData = {};
-                                for (const shardDoc of shardsSnapshot.docs) {
-                                    const shardData = shardDoc.data();
-                                    Object.assign(mergedData, shardData);
-                                }
-                            }
-                        } else {
-                            // Data is in the main document (compressed or not)
-                            const { tryDecompress } = require('../data_helpers');
-                            mergedData = tryDecompress(docData);
-                            
-                            // Handle string decompression result
-                            if (typeof mergedData === 'string') {
-                                try {
-                                    mergedData = JSON.parse(mergedData);
-                                } catch (e) {
-                                    logger.log('WARN', `[getUserSyncStatus] Failed to parse decompressed string for date ${dateStrFormatted}:`, e.message);
-                                    mergedData = null;
-                                }
-                            }
-                        }
-                        
-                        if (mergedData && typeof mergedData === 'object' && mergedData[String(targetCidNum)]) {
-                            // Computation completed! Update status
-                            status = 'completed';
-                            await requestsSnapshot.docs[0].ref.update({
-                                status: 'completed',
-                                completedAt: FieldValue.serverTimestamp(),
-                                updatedAt: FieldValue.serverTimestamp()
-                            });
-                            logger.log('INFO', `[getUserSyncStatus] Computation completed for user ${targetCidNum} (${userType}). Found results in date ${dateStrFormatted}`);
-                            break;
-                        }
-                    }
-                }
-            }
-            
-            // 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 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 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) {
-                    // Before marking as stale, do one final check for computation results
-                    // Sometimes computation completes but status wasn't updated
-                    const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-                    const resultsSub = config.resultsSubcollection || 'results';
-                    const compsSub = config.computationsSubcollection || 'computations';
-                    const finalCheck = await checkComputationResults(db, targetCidNum, userType, insightsCollection, resultsSub, compsSub, logger);
-                    if (!finalCheck) {
-                        isStale = true;
-                        logger.log('WARN', `[getUserSyncStatus] Detected stale request ${latestRequest.requestId} for user ${targetCidNum}. Status: ${status}, Age: ${Math.round((now - referenceTime) / 60000)} minutes`);
-                    } else {
-                        // Found results, update status to completed
-                        status = 'completed';
-                        await requestsSnapshot.docs[0].ref.update({
-                            status: 'completed',
-                            completedAt: FieldValue.serverTimestamp(),
-                            updatedAt: FieldValue.serverTimestamp()
-                        });
-                        logger.log('INFO', `[getUserSyncStatus] Found computation results on stale check, marked as completed`);
-                    }
-                }
-            }
-            
-            // 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);
-                }
-            }
-            
-            // Re-fetch request if we updated it to get the latest completedAt
-            let completedAt = latestRequest.completedAt?.toDate?.()?.toISOString() || null;
-            if (status === 'completed' && !completedAt) {
-                // If we just updated to completed, re-fetch to get the server timestamp
-                const updatedDoc = await requestsSnapshot.docs[0].ref.get();
-                if (updatedDoc.exists) {
-                    const updatedData = updatedDoc.data();
-                    completedAt = updatedData.completedAt?.toDate?.()?.toISOString() || null;
-                }
-            }
-            
-            const response = {
-                success: true,
-                status,
-                requestId: latestRequest.requestId,
-                startedAt: latestRequest.startedAt?.toDate?.()?.toISOString() || null,
-                createdAt: latestRequest.createdAt?.toDate?.()?.toISOString() || null,
-                dispatchedAt: latestRequest.dispatchedAt?.toDate?.()?.toISOString() || null,
-                completedAt: completedAt,
-                estimatedCompletion: latestRequest.dispatchedAt 
-                    ? new Date(new Date(latestRequest.dispatchedAt.toDate()).getTime() + 5 * 60 * 1000).toISOString() // 5 min estimate
-                    : null
-            };
-            
-            // Include error details if status is failed
-            if (status === 'failed') {
-                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
-            if (status === 'processing' || status === 'indexing' || status === 'computing') {
-                response.rawDataStoredAt = latestRequest.rawDataStoredAt?.toDate?.()?.toISOString() || null;
-                response.message = status === 'indexing' ? 'Raw data stored, indexing data...' : 
-                                 status === 'computing' ? 'Raw data stored, computation in progress...' :
-                                 'Processing data...';
-            }
-            
-            return res.status(200).json(response);
-        }
-        
-        // No request found, check if user can request
-        let canRequest = true;
-        let rateLimitInfo = null;
-        let lastUpdatedInfo = null;
-        
-        // Check last updated times for the target user
-        try {
-            const { collectionRegistry } = dependencies;
-            const HOURS_THRESHOLD = 24;
-            const thresholdMs = HOURS_THRESHOLD * 60 * 60 * 1000;
-            const now = Date.now();
-            
-            // Determine user type (PI or signed-in user)
-            const referrer = req.headers.referer || req.headers.referrer || '';
-            const sourcePage = req.query?.sourcePage || '';
-            const isPI = referrer.includes('/popular-investors/') || sourcePage === 'popular-investor';
-            
-            // [FIX] Get user document path (not lastUpdated subpath)
-            let userDocPath;
-            if (collectionRegistry && collectionRegistry.getCollectionPath) {
-                try {
-                    if (isPI) {
-                        // Use PI document path: PopularInvestors/{cid}
-                        userDocPath = `PopularInvestors/${targetCidNum}`;
-                    } else {
-                        // Use signed-in user document path: SignedInUsers/{cid}
-                        userDocPath = `SignedInUsers/${targetCidNum}`;
-                    }
-                } catch (err) {
-                    logger.log('WARN', `[getUserSyncStatus] Failed to get user document path: ${err.message}`);
-                }
-            } else {
-                // Fallback
-                userDocPath = isPI ? `PopularInvestors/${targetCidNum}` : `SignedInUsers/${targetCidNum}`;
-            }
-            
-            if (userDocPath) {
-                const userDocRef = db.doc(userDocPath);
-                const userDoc = await userDocRef.get();
-                
-                if (userDoc.exists) {
-                    const userData = userDoc.data();
-                    // [FIX] Access nested lastUpdated fields
-                    const lastUpdatedData = userData?.lastUpdated || {};
-                    const dataTypes = ['portfolio', 'tradeHistory', 'socialPosts'];
-                    const allRecent = dataTypes.every(dataType => {
-                        const lastUpdated = lastUpdatedData[dataType];
-                        if (!lastUpdated) return false;
-                        
-                        const lastUpdatedMs = lastUpdated.toDate?.()?.getTime() || lastUpdated.toMillis?.() || null;
-                        return lastUpdatedMs && (now - lastUpdatedMs) < thresholdMs;
-                    });
-                    
-                    if (allRecent) {
-                        // All data types were updated recently - disable sync
-                        canRequest = false;
-                        const oldestUpdate = Math.min(...dataTypes.map(dataType => {
-                            const lastUpdated = lastUpdatedData[dataType];
-                            const lastUpdatedMs = lastUpdated.toDate?.()?.getTime() || lastUpdated.toMillis?.() || null;
-                            return lastUpdatedMs || 0;
-                        }).filter(ms => ms > 0));
-                        
-                        const canRequestAgainAt = new Date(oldestUpdate + thresholdMs).toISOString();
-                        lastUpdatedInfo = {
-                            allDataTypesRecent: true,
-                            canRequestAgainAt,
-                            lastUpdated: {
-                                portfolio: lastUpdatedData.portfolio?.toDate?.()?.toISOString() || null,
-                                tradeHistory: lastUpdatedData.tradeHistory?.toDate?.()?.toISOString() || null,
-                                socialPosts: lastUpdatedData.socialPosts?.toDate?.()?.toISOString() || null
-                            }
-                        };
-                    } else {
-                        // Some data types need updating - allow sync
-                        lastUpdatedInfo = {
-                            allDataTypesRecent: false,
-                            lastUpdated: {
-                                portfolio: lastUpdatedData.portfolio?.toDate?.()?.toISOString() || null,
-                                tradeHistory: lastUpdatedData.tradeHistory?.toDate?.()?.toISOString() || null,
-                                socialPosts: lastUpdatedData.socialPosts?.toDate?.()?.toISOString() || null
-                            }
-                        };
-                    }
-                }
-            }
-        } catch (lastUpdatedError) {
-            logger.log('WARN', `[getUserSyncStatus] Error checking last updated times: ${lastUpdatedError.message}`);
-            // Non-critical, continue with rate limit check
-        }
-        
-        if (requestingUserCid) {
-            // Check if this is a developer account (bypass rate limits for developers)
-            const { isDeveloperAccount } = require('../dev/dev_helpers');
-            const isDeveloper = isDeveloperAccount(requestingUserCid);
-            
-            if (isDeveloper) {
-                // Developer accounts bypass rate limits (but still respect last updated check)
-                rateLimitInfo = {
-                    bypassed: true,
-                    reason: 'developer_account'
-                };
-            } else {
-                const rateLimitCheck = await checkRateLimits(db, targetCidNum, logger);
-                // Combine rate limit and last updated checks - both must pass
-                if (!rateLimitCheck.allowed) {
-                    canRequest = false;
-                }
-                rateLimitInfo = {
-                    canRequestAgainAt: rateLimitCheck.canRequestAgainAt
-                };
-            }
-        }
-        
-        return res.status(200).json({
-            success: true,
-            status: 'not_requested',
-            canRequest,
-            rateLimit: rateLimitInfo,
-            lastUpdated: lastUpdatedInfo
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getUserSyncStatus] Error checking sync status for user ${targetCidNum}`, error);
-        return res.status(500).json({
-            success: false,
-            error: "Internal server error",
-            message: error.message
-        });
-    }
-}
-
-/**
- * Check global rate limits for a user
- * NOTE: Developer accounts should bypass this check (check isDeveloperAccount before calling)
- */
-async function checkRateLimits(db, targetUserCid, logger) {
-    const now = Date.now();
-    
-    // Check global rate limit (applies to target user, not requester)
-    const globalRef = db.collection('user_sync_requests')
-        .doc(String(targetUserCid))
-        .collection('global')
-        .doc('latest');
-    
-    const globalDoc = await globalRef.get();
-    let canRequestAgainAt = null;
-    let blocked = false;
-    let lastRequestedAt = null;
-    
-    if (globalDoc.exists) {
-        const globalData = globalDoc.data();
-        const globalLastRequestedAt = globalData.lastRequestedAt?.toDate?.()?.getTime() || globalData.lastRequestedAt?.toMillis?.() || null;
-        
-        if (globalLastRequestedAt && (now - globalLastRequestedAt) < RATE_LIMIT_MS) {
-            blocked = true;
-            canRequestAgainAt = new Date(globalLastRequestedAt + RATE_LIMIT_MS).toISOString();
-            lastRequestedAt = new Date(globalLastRequestedAt).toISOString();
-        }
-    }
-    
-    if (blocked) {
-        const hoursRemaining = Math.ceil((new Date(canRequestAgainAt).getTime() - now) / (60 * 60 * 1000));
-        return {
-            allowed: false,
-            message: `This user was recently synced. Please try again in ${hoursRemaining} hour${hoursRemaining !== 1 ? 's' : ''}.`,
-            canRequestAgainAt,
-            lastRequestedAt
-        };
-    }
-    
-    return {
-        allowed: true,
-        canRequestAgainAt: new Date(now + RATE_LIMIT_MS).toISOString()
-    };
-}
-
-/**
- * Helper function to check for computation results
- */
-async function checkComputationResults(db, targetCidNum, userType, insightsCollection, resultsSub, compsSub, logger) {
-    try {
-        // Determine category and computation name based on user type
-        // 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
-        let category, computationName;
-        if (userType === 'POPULAR_INVESTOR') {
-            category = 'popular-investor';
-            computationName = 'PopularInvestorProfileMetrics';
-        } else {
-            // SignedInUserProfileMetrics is in popular-investor folder, so stored in popular-investor category
-            category = 'popular-investor';
-            computationName = 'SignedInUserProfileMetrics';
-        }
-        
-        // Check today and yesterday for computation results
-        const checkDate = new Date();
-        for (let i = 0; i < 2; i++) {
-            const dateStr = new Date(checkDate);
-            dateStr.setDate(checkDate.getDate() - i);
-            const dateStrFormatted = dateStr.toISOString().split('T')[0];
-            
-            const docRef = db.collection(insightsCollection)
-                .doc(dateStrFormatted)
-                .collection(resultsSub)
-                .doc(category)
-                .collection(compsSub)
-                .doc(computationName);
-            
-            const doc = await docRef.get();
-            if (doc.exists) {
-                const docData = doc.data();
-                let mergedData = null;
-                
-                // Check if data is sharded
-                if (docData._sharded === true && docData._shardCount) {
-                    const shardsCol = docRef.collection('_shards');
-                    const shardsSnapshot = await shardsCol.get();
-                    
-                    if (!shardsSnapshot.empty) {
-                        mergedData = {};
-                        for (const shardDoc of shardsSnapshot.docs) {
-                            const shardData = shardDoc.data();
-                            Object.assign(mergedData, shardData);
-                        }
-                    }
-                } else {
-                    const { tryDecompress } = require('../data_helpers');
-                    mergedData = tryDecompress(docData);
-                    
-                    if (typeof mergedData === 'string') {
-                        try {
-                            mergedData = JSON.parse(mergedData);
-                        } catch (e) {
-                            mergedData = null;
-                        }
-                    }
-                }
-                
-                if (mergedData && typeof mergedData === 'object' && mergedData[String(targetCidNum)]) {
-                    return true; // Found results
-                }
-            }
-        }
-        return false; // No results found
-    } catch (error) {
-        logger.log('WARN', `[checkComputationResults] Error checking computation results`, error);
-        return false;
-    }
-}
-
-module.exports = {
-    requestUserSync,
-    getUserSyncStatus
-};