bulltrackers-module 1.0.471 → 1.0.473

package/functions/alert-system/helpers/alert_helpers.js

@@ -16,7 +16,8 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     const piUsername = await getPIUsername(db, piCid);
     
     // 2. Find all users subscribed to this PI and alert type
-    const subscriptions = await findSubscriptionsForPI(db, piCid, alertType.id);
+    // Use computationName (e.g., 'RiskScoreIncrease') to map to alertConfig keys
+    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName);
     
     if (subscriptions.length === 0) {
       logger.log('INFO', `[processAlertForPI] No subscriptions found for PI ${piCid}, alert type ${alertType.id}`);
@@ -28,37 +29,41 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     // 3. Generate alert message
     const alertMessage = generateAlertMessage(alertType, piUsername, computationMetadata);
     
-    // 4. Create alerts for each subscribed user
+    // 4. Create notifications for each subscribed user (using user_notifications collection)
     const batch = db.batch();
-    const alertRefs = [];
+    const notificationRefs = [];
     const counterUpdates = {};
     
     for (const subscription of subscriptions) {
-      const alertId = `alert_${Date.now()}_${subscription.userCid}_${piCid}`;
-      const alertRef = db.collection('user_alerts')
+      const notificationId = `alert_${Date.now()}_${subscription.userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
+      const notificationRef = db.collection('user_notifications')
         .doc(String(subscription.userCid))
-        .collection('alerts')
-        .doc(alertId);
+        .collection('notifications')
+        .doc(notificationId);
       
-      const alertData = {
-        id: alertId,
-        userCid: subscription.userCid,
-        piCid: piCid,
-        piUsername: piUsername,
-        alertType: alertType.id,
-        alertTypeName: alertType.name,
-        computationName: alertType.computationName,
-        computationDate: computationDate,
+      const notificationData = {
+        id: notificationId,
+        type: 'alert',
+        title: alertType.name,
         message: alertMessage,
-        severity: alertType.severity,
         read: false,
-        readAt: null,
         createdAt: FieldValue.serverTimestamp(),
-        metadata: computationMetadata || {}
+        metadata: {
+          piCid: Number(piCid),
+          piUsername: piUsername,
+          alertType: alertType.id,
+          alertTypeName: alertType.name,
+          computationName: alertType.computationName,
+          computationDate: computationDate,
+          severity: alertType.severity,
+          watchlistId: subscription.watchlistId,
+          watchlistName: subscription.watchlistName,
+          ...(computationMetadata || {})
+        }
       };
       
-      batch.set(alertRef, alertData);
-      alertRefs.push(alertRef);
+      batch.set(notificationRef, notificationData);
+      notificationRefs.push(notificationRef);
       
       // Track counter updates
       const dateKey = computationDate || new Date().toISOString().split('T')[0];
@@ -76,9 +81,9 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
         (counterUpdates[subscription.userCid].byType[alertType.id] || 0) + 1;
     }
     
-    // 5. Update alert counters
+    // 5. Update notification counters
     for (const [userCid, counter] of Object.entries(counterUpdates)) {
-      const counterRef = db.collection('user_alerts')
+      const counterRef = db.collection('user_notifications')
         .doc(String(userCid))
         .collection('counters')
         .doc(counter.date);
@@ -92,25 +97,10 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
       }, { merge: true });
     }
     
-    // 6. Update subscription lastAlertAt
-    for (const subscription of subscriptions) {
-      const subscriptionRef = db.collection('watchlist_subscriptions')
-        .doc(String(subscription.userCid))
-        .collection('alerts')
-        .doc(String(piCid));
-      
-      batch.update(subscriptionRef, {
-        lastAlertAt: FieldValue.serverTimestamp()
-      });
-    }
-    
-    // 7. Commit batch
+    // 6. Commit batch
     await batch.commit();
     
-    logger.log('SUCCESS', `[processAlertForPI] Created ${alertRefs.length} alerts for PI ${piCid}, alert type ${alertType.id}`);
-    
-    // 8. Optionally notify the PI if they're a signed-in user
-    await notifyPIIfSignedIn(db, logger, piCid, alertType, subscriptions.length);
+    logger.log('SUCCESS', `[processAlertForPI] Created ${notificationRefs.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
   } catch (error) {
     logger.log('ERROR', `[processAlertForPI] Error processing alert for PI ${piCid}`, error);
@@ -119,35 +109,67 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
 }
 
 /**
- * Find all subscriptions for a PI and alert type
+ * Find all users who should receive alerts for a PI and alert type
+ * Reads from actual watchlist structure: watchlists/{userCid}/lists/{watchlistId}
  */
-async function findSubscriptionsForPI(db, piCid, alertTypeId) {
+async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
   const subscriptions = [];
   
-  // Query all users who have subscriptions
-  const subscriptionsCollection = db.collection('watchlist_subscriptions');
-  const snapshot = await subscriptionsCollection
-    .where('piCid', '==', Number(piCid))
-    .get();
+  // Map computation names to watchlist alertConfig keys
+  // The alertTypeId is actually the computation name (e.g., 'RiskScoreIncrease')
+  const computationToConfigKey = {
+    'RiskScoreIncrease': 'increasedRisk',
+    'SignificantVolatility': 'volatilityChanges',
+    'NewSectorExposure': 'newSector',
+    'PositionInvestedIncrease': 'increasedPositionSize',
+    'NewSocialPost': 'newSocialPost',
+    'NewPositions': 'newPositions' // If this computation exists
+  };
   
-  for (const doc of snapshot.docs) {
-    const data = doc.data();
-    const userCid = data.userCid;
+  const configKey = computationToConfigKey[alertTypeId];
+  if (!configKey) {
+    logger.log('WARN', `[findSubscriptionsForPI] No mapping found for alert type: ${alertTypeId}`);
+    return subscriptions;
+  }
+  
+  // Get all watchlists
+  const watchlistsCollection = db.collection('watchlists');
+  const watchlistsSnapshot = await watchlistsCollection.get();
+  
+  for (const userDoc of watchlistsSnapshot.docs) {
+    const userCid = Number(userDoc.id);
+    const userListsSnapshot = await userDoc.ref.collection('lists').get();
     
-    // Check if this user is subscribed to this alert type
-    if (data.alertTypes && data.alertTypes[alertTypeId] === true) {
-      // Check thresholds if applicable
-      if (shouldTriggerAlert(data, alertTypeId)) {
-        subscriptions.push({
-          userCid: userCid,
-          piCid: piCid,
-          alertTypes: data.alertTypes,
-          thresholds: data.thresholds || {}
-        });
+    for (const listDoc of userListsSnapshot.docs) {
+      const listData = listDoc.data();
+      
+      // Check static watchlists
+      if (listData.type === 'static' && listData.items && Array.isArray(listData.items)) {
+        for (const item of listData.items) {
+          if (Number(item.cid) === Number(piCid)) {
+            // Check if this alert type is enabled for this PI in this watchlist
+            if (item.alertConfig && item.alertConfig[configKey] === true) {
+              subscriptions.push({
+                userCid: userCid,
+                piCid: piCid,
+                piUsername: item.username || `PI-${piCid}`,
+                watchlistId: listDoc.id,
+                watchlistName: listData.name || 'Unnamed Watchlist',
+                alertConfig: item.alertConfig
+              });
+              break; // Found in this watchlist, no need to check other items
+            }
+          }
+        }
       }
+      
+      // Check dynamic watchlists - if the PI matches the computation result, check alertConfig
+      // Note: Dynamic watchlists are handled separately as they're based on computation results
+      // For now, we only process static watchlists here
     }
   }
   
+  logger.log('INFO', `[findSubscriptionsForPI] Found ${subscriptions.length} subscriptions for PI ${piCid}, alert type ${alertTypeId}`);
   return subscriptions;
 }
 
@@ -336,10 +358,41 @@ function readComputationResults(docData) {
   }
 }
 
+/**
+ * Read computation results, handling sharded data
+ */
+async function readComputationResultsWithShards(db, docData, docRef) {
+  try {
+    // 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) {
+        let mergedData = {};
+        for (const shardDoc of shardsSnapshot.docs) {
+          const shardData = shardDoc.data();
+          const decompressed = tryDecompress(shardData);
+          Object.assign(mergedData, decompressed);
+        }
+        return readComputationResults(mergedData);
+      }
+    }
+    
+    // Data is in the main document (compressed or not)
+    return readComputationResults(docData);
+  } catch (error) {
+    console.error('[readComputationResultsWithShards] Error reading sharded results', error);
+    return { cids: [], metadata: {}, perUserData: {} };
+  }
+}
+
 module.exports = {
   processAlertForPI,
   findSubscriptionsForPI,
   getPIUsername,
-  readComputationResults
+  readComputationResults,
+  readComputationResultsWithShards
 };
 

package/functions/alert-system/index.js

@@ -4,7 +4,7 @@
  */
 
 const { getAlertTypeByComputation, isAlertComputation } = require('./helpers/alert_type_registry');
-const { processAlertForPI, readComputationResults } = require('./helpers/alert_helpers');
+const { processAlertForPI, readComputationResults, readComputationResultsWithShards } = require('./helpers/alert_helpers');
 
 /**
  * Pub/Sub trigger handler for alert generation
@@ -126,13 +126,33 @@ async function handleAlertTrigger(message, context, config, dependencies) {
 }
 
 /**
- * Firestore trigger function for alert generation (if using Firestore triggers)
+ * Firestore trigger function for alert generation
  * Triggered when computation results are written to:
- * unified_insights/{date}/results/popular-investor/computations/{computationName}
+ * unified_insights/{date}/results/{category}/computations/{computationName}
+ * 
+ * Handles sharded data by checking _shards subcollection if _sharded === true
  */
 async function handleComputationResultWrite(change, context, config, dependencies) {
   const { db, logger } = dependencies;
-  const { date, computationName } = context.params;
+  
+  // Extract path parameters from the document path
+  // Path format: unified_insights/{date}/results/{category}/computations/{computationName}
+  const resource = context.resource || change.after.ref.path;
+  const pathParts = resource.split('/');
+  
+  // Find indices of key path segments
+  const dateIndex = pathParts.indexOf('unified_insights') + 1;
+  const categoryIndex = pathParts.indexOf('results') + 1;
+  const computationIndex = pathParts.indexOf('computations') + 1;
+  
+  if (dateIndex === 0 || categoryIndex === 0 || computationIndex === 0) {
+    logger.log('WARN', `[AlertTrigger] Invalid document path format: ${resource}`);
+    return;
+  }
+  
+  const date = pathParts[dateIndex];
+  const category = pathParts[categoryIndex];
+  const computationName = pathParts[computationIndex];
   
   // Only process if document was created or updated (not deleted)
   if (!change.after.exists) {
@@ -148,10 +168,16 @@ async function handleComputationResultWrite(change, context, config, dependencie
       return;
     }
     
+    // Only process popular-investor category computations
+    if (category !== 'popular-investor') {
+      logger.log('DEBUG', `[AlertTrigger] Not popular-investor category: ${category}`);
+      return;
+    }
+    
     // If it's PopularInvestorProfileMetrics, check for all-clear notifications only
     if (isProfileMetrics) {
       const docData = change.after.data();
-      const results = readComputationResults(docData);
+      const results = await readComputationResultsWithShards(db, docData, change.after.ref);
       if (results.cids && results.cids.length > 0) {
         await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
       }
@@ -166,9 +192,9 @@ async function handleComputationResultWrite(change, context, config, dependencie
     
     logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
     
-    // 2. Read and decompress computation results
+    // 2. Read and decompress computation results (handling shards)
     const docData = change.after.data();
-    const results = readComputationResults(docData);
+    const results = await readComputationResultsWithShards(db, docData, change.after.ref);
     
     if (!results.cids || results.cids.length === 0) {
       logger.log('INFO', `[AlertTrigger] No PIs found in computation results for ${computationName}`);
@@ -178,6 +204,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
     logger.log('INFO', `[AlertTrigger] Found ${results.cids.length} PIs in ${computationName} results`);
     
     // 3. Process alerts for each PI
+    // Use computationName as the alertTypeId (it maps to alertConfig keys)
     let processedCount = 0;
     let errorCount = 0;
     
@@ -186,7 +213,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
         // Extract PI-specific metadata if available, otherwise use global metadata
         const piMetadata = results.perUserData && results.perUserData[piCid] 
           ? results.perUserData[piCid]
-          : results.metadata || {};
+          : results.metadata || results.globalMetadata || {};
         
         await processAlertForPI(
           db,
@@ -206,12 +233,6 @@ async function handleComputationResultWrite(change, context, config, dependencie
     
     logger.log('SUCCESS', `[AlertTrigger] Completed processing ${computationName}: ${processedCount} successful, ${errorCount} errors`);
     
-    // After processing alerts, check for "all clear" notifications for static watchlists
-    if (processedCount > 0 || results.cids.length > 0) {
-      // Check if any PIs were processed but didn't trigger alerts
-      await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
-    }
-    
   } catch (error) {
     logger.log('ERROR', `[AlertTrigger] Fatal error processing ${computationName}`, error);
     // Don't throw - we don't want to retry the entire computation write
@@ -238,7 +259,7 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
     const usersToNotify = new Map(); // userCid -> Map of piCid -> {username, ...}
     
     for (const userDoc of watchlistsSnapshot.docs) {
-      const userCid = userDoc.id;
+      const userCid = Number(userDoc.id);
       const userListsSnapshot = await userDoc.ref.collection('lists').get();
       
       for (const listDoc of userListsSnapshot.docs) {
@@ -253,8 +274,8 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
         for (const item of listData.items) {
           const piCid = Number(item.cid);
           if (processedPICids.includes(piCid)) {
-            // Check if this PI triggered any alerts today
-            const hasAlerts = await checkIfPIHasAlertsToday(db, userCid, piCid, today);
+            // Check if this PI triggered any alerts today for this user
+            const hasAlerts = await checkIfPIHasAlertsToday(db, logger, userCid, piCid, today);
             
             if (!hasAlerts) {
               // No alerts triggered - send "all clear" notification
@@ -292,28 +313,28 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
 
 /**
  * Check if a PI has any alerts for a user today
+ * Checks user_notifications collection for alert-type notifications
  */
-async function checkIfPIHasAlertsToday(db, userCid, piCid, date) {
+async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date) {
   try {
-    const alertsRef = db.collection('user_alerts')
+    const notificationsRef = db.collection('user_notifications')
       .doc(String(userCid))
-      .collection('alerts');
-    
-    // Check if there are any alerts for this PI today
-    const todayStart = new Date(date);
-    todayStart.setHours(0, 0, 0, 0);
-    const todayEnd = new Date(date);
-    todayEnd.setHours(23, 59, 59, 999);
+      .collection('notifications');
     
-    const snapshot = await alertsRef
-      .where('piCid', '==', Number(piCid))
-      .where('computationDate', '==', date)
+    // Check if there are any alert notifications for this PI today
+    const snapshot = await notificationsRef
+      .where('type', '==', 'alert')
+      .where('metadata.piCid', '==', Number(piCid))
+      .where('metadata.computationDate', '==', date)
       .limit(1)
       .get();
     
     return !snapshot.empty;
   } catch (error) {
-    // If we can't check, assume there are alerts (safer)
+    if (logger) {
+      logger.log('WARN', `[checkIfPIHasAlertsToday] Error checking alerts for user ${userCid}, PI ${piCid}: ${error.message}`);
+    }
+    // If we can't check, assume there are alerts (safer - won't send false all-clear)
     return true;
   }
 }

package/functions/computation-system/persistence/ResultCommitter.js

@@ -202,15 +202,10 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
         await updateComputationStatus(dStr, successUpdates, config, deps); 
     }
 
-    // Flush Alert Triggers to Pub/Sub
+    // Alert triggers are now handled via Firestore triggers
+    // No need to publish Pub/Sub messages - the Firestore write itself triggers the alert system
     if (alertTriggers.length > 0) {
-        const topicName = config.alertTopicName || 'alert-trigger';
-        try {
-            await pubSubUtils.publishMessageBatch(topicName, alertTriggers);
-            logger.log('INFO', `[Alert System] Triggered ${alertTriggers.length} alerts to ${topicName}`);
-        } catch (alertErr) {
-            logger.log('ERROR', `[Alert System] Failed to publish alerts: ${alertErr.message}`);
-        }
+        logger.log('INFO', `[Alert System] ${alertTriggers.length} alert computations written to Firestore - triggers will fire automatically`);
     }
     
     return { successUpdates, failureReport, shardIndexes: nextShardIndexes };

package/index.js

@@ -57,7 +57,7 @@ const { runRootDataIndexer }                              = require('./functions
 const { runPopularInvestorFetch }                         = require('./functions/fetch-popular-investors/index');
 
 // Alert System
-const { handleAlertTrigger, handleComputationResultWrite } = require('./functions/alert-system/index');
+const { handleAlertTrigger, handleComputationResultWrite, checkAndSendAllClearNotifications } = require('./functions/alert-system/index');
 
 // Proxy
 const { handlePost }                                      = require('./functions/appscript-api/index');
@@ -126,8 +126,9 @@ const maintenance = {
 const proxy = { handlePost };
 
 const alertSystem = {
-  handleAlertTrigger,
-  handleComputationResultWrite
+  handleAlertTrigger, // Pub/Sub handler (kept for backward compatibility, but not used)
+  handleComputationResultWrite, // Firestore trigger handler - main entry point
+  checkAndSendAllClearNotifications
 };
 
 module.exports = {

package/package.json

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