bulltrackers-module 1.0.537 → 1.0.539

package/functions/generic-api/user-api/helpers/data/social_helpers.js

@@ -1,46 +1,165 @@
 /**
  * @fileoverview Social Posts Data Helpers
  * Handles user social posts endpoints
+ * UPDATED: Uses collection registry to read from root data collection
  */
 
+const { findLatestRankingsDate } = require('../core/data_lookup_helpers');
+const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
+
+/**
+ * Find the latest available date for signed-in user social posts
+ * Searches backwards from today up to maxDaysBack days
+ * @param {Firestore} db - Firestore instance
+ * @param {string|number} userCid - User CID
+ * @param {object} collectionRegistry - Collection registry (injected at runtime)
+ * @param {number} maxDaysBack - Maximum days to search backwards (default: 30)
+ * @returns {Promise<string|null>} - Date string (YYYY-MM-DD) or null if not found
+ */
+async function findLatestSocialDate(db, userCid, collectionRegistry, maxDaysBack = 30) {
+    const today = new Date();
+    
+    // Get collection name from registry
+    let collectionName = 'SignedInUserSocialPostData'; // Default fallback
+    if (collectionRegistry && collectionRegistry.getCollectionPath) {
+        try {
+            // Extract collection name from registry path template
+            const samplePath = collectionRegistry.getCollectionPath('rootData', 'signedInUserSocial', { 
+                date: '2025-01-01', 
+                cid: '123' 
+            });
+            collectionName = samplePath.split('/')[0]; // Extract collection name
+        } catch (e) {
+            // Use default collection name
+        }
+    }
+    
+    for (let i = 0; i < maxDaysBack; i++) {
+        const checkDate = new Date(today);
+        checkDate.setDate(checkDate.getDate() - i);
+        const dateStr = checkDate.toISOString().split('T')[0];
+        
+        try {
+            // Construct path: SignedInUserSocialPostData/{date}/{cid}/{cid}
+            const socialDocRef = db.collection(collectionName)
+                .doc(dateStr)
+                .collection(String(userCid))
+                .doc(String(userCid));
+            
+            const socialDoc = await socialDocRef.get();
+            
+            if (socialDoc.exists) {
+                const data = socialDoc.data();
+                if (data.posts && Object.keys(data.posts).length > 0) {
+                    return dateStr; // Found social posts for this date
+                }
+            }
+        } catch (error) {
+            // Continue to next date if error
+            continue;
+        }
+    }
+    
+    return null; // No social posts found in the last maxDaysBack days
+}
+
 /**
  * GET /user/me/social-posts
- * Fetches the signed-in user's social posts
+ * Fetches the signed-in user's social posts from root data collection
  */
 async function getUserSocialPosts(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
+    const { db, logger, collectionRegistry } = dependencies;
+    const { userCid, date } = req.query;
     
     if (!userCid) {
         return res.status(400).json({ error: "Missing userCid" });
     }
 
     try {
-        const { signedInSocialCollection } = config;
-        const socialCollection = signedInSocialCollection || 'signed_in_users_social';
-        
-        // Fetch posts from signed_in_users_social/{cid}/posts
-        const postsRef = db.collection(socialCollection)
-            .doc(String(userCid))
-            .collection('posts');
-        
-        const postsSnapshot = await postsRef
-            .orderBy('createdAt', 'desc')
-            .limit(50) // Limit to 50 most recent posts
-            .get();
-        
-        const posts = [];
-        postsSnapshot.forEach(doc => {
-            posts.push({
-                id: doc.id,
-                ...doc.data()
+        // Check for dev override impersonation
+        const effectiveCid = await getEffectiveCid(db, userCid, config, logger);
+        const devOverride = await getDevOverride(db, userCid, config, logger);
+        const isImpersonating = devOverride && devOverride.enabled && devOverride.impersonateCid && effectiveCid !== Number(userCid);
+        
+        const today = new Date().toISOString().split('T')[0];
+        
+        // Determine which date to use
+        let dataDate = date || today;
+        let isFallback = false;
+        
+        // If no specific date requested, find latest available date
+        if (!date) {
+            dataDate = await findLatestSocialDate(db, effectiveCid, collectionRegistry, 30);
+            if (!dataDate) {
+                return res.status(404).json({ 
+                    error: "Social posts not found for this user (checked last 30 days)",
+                    effectiveCid: effectiveCid,
+                    isImpersonating: isImpersonating || false
+                });
+            }
+            isFallback = dataDate !== today;
+            if (isFallback) {
+                logger.log('INFO', `[getUserSocialPosts] Using fallback date ${dataDate} for effective CID ${effectiveCid} (today: ${today})`);
+            }
+        }
+        
+        // Get collection name from registry
+        let collectionName = 'SignedInUserSocialPostData'; // Default fallback
+        if (collectionRegistry && collectionRegistry.getCollectionPath) {
+            try {
+                // Extract collection name from registry path template
+                const samplePath = collectionRegistry.getCollectionPath('rootData', 'signedInUserSocial', { 
+                    date: '2025-01-01', 
+                    cid: '123' 
+                });
+                collectionName = samplePath.split('/')[0]; // Extract collection name
+            } catch (e) {
+                logger.log('WARN', `[getUserSocialPosts] Failed to get collection name from registry, using default: ${e.message}`);
+            }
+        }
+        
+        // Construct path: SignedInUserSocialPostData/{date}/{cid}/{cid}
+        const socialDocRef = db.collection(collectionName)
+            .doc(dataDate)
+            .collection(String(effectiveCid))
+            .doc(String(effectiveCid));
+        
+        const socialDoc = await socialDocRef.get();
+        
+        if (!socialDoc.exists) {
+            return res.status(404).json({ 
+                error: "Social posts not found",
+                date: dataDate,
+                effectiveCid: effectiveCid,
+                isImpersonating: isImpersonating || false
             });
-        });
+        }
+        
+        const socialData = socialDoc.data();
+        const postsMap = socialData.posts || {};
+        
+        // Convert posts map to array and sort by createdAt (descending)
+        const posts = Object.entries(postsMap)
+            .map(([postId, postData]) => ({
+                id: postId,
+                ...postData
+            }))
+            .sort((a, b) => {
+                const dateA = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+                const dateB = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+                return dateB - dateA; // Descending order
+            })
+            .slice(0, 50); // Limit to 50 most recent posts
         
         return res.status(200).json({
             posts,
             count: posts.length,
-            userCid: String(userCid)
+            date: dataDate,
+            isFallback: isFallback,
+            requestedDate: date || today,
+            userCid: String(userCid),
+            effectiveCid: effectiveCid,
+            isImpersonating: isImpersonating || false
         });
 
     } catch (error) {

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

@@ -5,17 +5,62 @@
 
 const { FieldValue } = require('@google-cloud/firestore');
 
+/**
+ * Get the detail field name for a data type
+ * @param {string} dataType - Data type identifier
+ * @returns {string} - Detail field name in the index document
+ */
+function getDetailFieldName(dataType) {
+    const dataTypeMap = {
+        'signedInUserPortfolio': 'signedInUserPortfolio',
+        'signedInUserHistory': 'signedInUserHistory',
+        'signedInUserSocial': 'signedInSocial',
+        'piPortfolios': 'piPortfolios',
+        'piHistory': 'piHistory',
+        'piSocial': 'piSocial',
+        'normalPortfolios': 'normalPortfolio',
+        'normalHistory': 'normalHistory',
+        'speculatorPortfolios': 'speculatorPortfolio',
+        'speculatorHistory': 'speculatorHistory'
+    };
+    return dataTypeMap[dataType] || dataType;
+}
+
 /**
  * Check if root data is already indexed for a specific date
  * @param {Firestore} db - Firestore instance
  * @param {string} dateStr - Date string (YYYY-MM-DD)
  * @param {string} availabilityCollection - Collection name for root data index
- * @returns {Promise<boolean>} - True if already indexed
+ * @param {Array<string>} dataTypesRun - Optional array of data types to verify are indexed (e.g., ['signedInUserPortfolio', 'piSocial'])
+ * @returns {Promise<boolean>} - True if already indexed (and all requested data types are indexed if provided)
  */
-async function isRootDataIndexed(db, dateStr, availabilityCollection = 'system_root_data_index') {
+async function isRootDataIndexed(db, dateStr, availabilityCollection = 'system_root_data_index', dataTypesRun = []) {
     try {
         const indexDoc = await db.collection(availabilityCollection).doc(dateStr).get();
-        return indexDoc.exists;
+        if (!indexDoc.exists) {
+            return false;
+        }
+        
+        // If specific data types were requested, verify they are actually indexed
+        if (dataTypesRun && dataTypesRun.length > 0) {
+            const indexData = indexDoc.data();
+            const details = indexData?.details || {};
+            
+            // Check if all requested data types are indexed (have true values)
+            // If any are false or missing, return false (needs indexing)
+            for (const dataType of dataTypesRun) {
+                const detailField = getDetailFieldName(dataType);
+                if (details[detailField] !== true) {
+                    // At least one requested data type is not indexed
+                    return false;
+                }
+            }
+            // All requested data types are indexed as true
+            return true;
+        }
+        
+        // No specific data types requested - just check if document exists
+        return true;
     } catch (error) {
         // If we can't check, assume not indexed to be safe
         return false;
@@ -39,11 +84,43 @@ async function conditionallyRunRootDataIndexer({ db, logger, dateStr, rootDataIn
     const { runRootDataIndexer } = require('../../root-data-indexer/index');
     const availabilityCollection = rootDataIndexerConfig?.availabilityCollection || 'system_root_data_index';
     
-    // Check if already indexed
-    const alreadyIndexed = await isRootDataIndexed(db, dateStr, availabilityCollection);
-    if (alreadyIndexed) {
-        logger.log('INFO', `[RootDataIndexer] Root data already indexed for ${dateStr}, skipping`);
-        return false;
+    // IMPORTANT: Only index data types that were successfully stored (dataTypesRun contains only successful operations)
+    // If a write failed, it won't be in dataTypesRun, so we won't try to index it
+    // However, we still run the indexer to check/update the types that did succeed
+    
+    // Check if already indexed (verify specific data types if provided)
+    // Only check the data types that were actually run - if they're all already true, skip indexing (never overwrite true values)
+    if (dataTypesRun.length > 0) {
+        const alreadyIndexed = await isRootDataIndexed(db, dateStr, availabilityCollection, dataTypesRun);
+        if (alreadyIndexed) {
+            logger.log('INFO', `[RootDataIndexer] All requested data types (${dataTypesRun.join(', ')}) are already indexed as true for ${dateStr}, skipping (never overwrite true values)`);
+            return false;
+        }
+        
+        // If document exists but data types aren't indexed, log it
+        try {
+            const indexDoc = await db.collection(availabilityCollection).doc(dateStr).get();
+            if (indexDoc.exists) {
+                const indexData = indexDoc.data();
+                const details = indexData?.details || {};
+                const missingTypes = dataTypesRun.filter(dt => {
+                    const detailField = getDetailFieldName(dt);
+                    return details[detailField] !== true;
+                });
+                if (missingTypes.length > 0) {
+                    logger.log('INFO', `[RootDataIndexer] Index document exists for ${dateStr} but data types (${missingTypes.join(', ')}) are not indexed. Re-indexing...`);
+                }
+            }
+        } catch (e) {
+            // Ignore errors checking document
+        }
+    } else {
+        // No specific data types - check if document exists (legacy behavior)
+        const alreadyIndexed = await isRootDataIndexed(db, dateStr, availabilityCollection, []);
+        if (alreadyIndexed) {
+            logger.log('INFO', `[RootDataIndexer] Root data already indexed for ${dateStr}, skipping`);
+            return false;
+        }
     }
     
     // Use Firestore transaction to ensure only one instance runs the indexer

package/package.json

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