bulltrackers-module 1.0.679 → 1.0.681

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

@@ -6,8 +6,8 @@
 const { FieldValue } = require('@google-cloud/firestore');
 const zlib = require('zlib');
 const { Storage } = require('@google-cloud/storage');
-const { getAlertTypeByComputation, generateAlertMessage } = require('./alert_type_registry');
-// Migration helpers removed - write directly to new path
+const { generateAlertMessage } = require('./alert_manifest_loader');
+// [UPDATED] Now uses dynamic manifest loading instead of hardcoded registry
 
 const storage = new Storage(); // Singleton GCS Client
 
@@ -222,21 +222,13 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
 async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computationDate, dependencies = {}) {
   const subscriptions = [];
   
-  // Map computation names to watchlist alertConfig keys
-  const computationToConfigKey = {
-    'RiskScoreIncrease': 'increasedRisk',
-    'SignificantVolatility': 'volatilityChanges',
-    'NewSectorExposure': 'newSector',
-    'PositionInvestedIncrease': 'increasedPositionSize',
-    'NewSocialPost': 'newSocialPost',
-    // [NEW] Mapping for BehavioralAnomaly
-    'BehavioralAnomaly': 'behavioralAnomaly',
-    'TestSystemProbe': 'increasedRisk' // Hack: Map to 'increasedRisk' key
-  };
+  // [DYNAMIC] Get configKey from alertType metadata instead of hardcoded mapping
+  // The alertType is passed in dependencies and contains the configKey from computation metadata
+  const alertType = dependencies.alertType;
+  const configKey = alertType?.configKey;
   
-  const configKey = computationToConfigKey[alertTypeId];
   if (!configKey) {
-    logger.log('WARN', `[findSubscriptionsForPI] No mapping found for alert type: ${alertTypeId}`);
+    logger.log('WARN', `[findSubscriptionsForPI] No configKey found for alert type: ${alertTypeId}`);
     return subscriptions;
   }
   
@@ -264,8 +256,8 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
       increasedPositionSize: true,
       newSocialPost: true,
       newPositions: true,
-      // [NEW] Enable for Dev Override
-      behavioralAnomaly: true
+      behavioralAnomaly: true,
+      testSystemProbe: true // Test alerts for developers
     };
     
     // Check all developer accounts
@@ -364,9 +356,13 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
               const isTestProbe = alertTypeId === 'TestSystemProbe';
               const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
               
-              // [FIX] For TestSystemProbe, check user's testAlerts preference
+              // [FIX] Check if this is a test alert (respect testAlerts preference)
+              // Load alert type from dependencies to check isTest flag
+              const alertType = dependencies.alertType;
+              const isTestAlert = alertType && alertType.isTest === true;
+              
               let shouldSendAlert = false;
-              if (isTestProbe) {
+              if (isTestAlert) {
                 // Check if user has testAlerts enabled in their notification preferences
                 try {
                   const { manageNotificationPreferences } = require('../../api-v2/helpers/data-fetchers/firestore.js');
@@ -374,7 +370,7 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
                   shouldSendAlert = prefs.testAlerts === true;
                   
                   if (!shouldSendAlert) {
-                    logger.log('DEBUG', `[findSubscriptionsForPI] User ${userCid} has testAlerts disabled, skipping TestSystemProbe alert`);
+                    logger.log('DEBUG', `[findSubscriptionsForPI] User ${userCid} has testAlerts disabled, skipping test alert ${alertTypeId}`);
                   }
                 } catch (prefError) {
                   logger.log('WARN', `[findSubscriptionsForPI] Error checking testAlerts preference for user ${userCid}: ${prefError.message}`);

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

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Dynamic Alert Manifest Loader
+ * Loads alert types from computation classes instead of hardcoded registry
+ */
+
+/**
+ * Flatten nested calculations object (same logic as index.js)
+ * @param {Object} obj - Nested calculations object
+ * @returns {Array<Function>} Flat array of computation classes
+ */
+const flattenCalculations = (obj) => {
+  let result = [];
+  for (const key in obj) {
+    if (typeof obj[key] === 'function') {
+      result.push(obj[key]);
+    } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+      result = result.concat(flattenCalculations(obj[key]));
+    }
+  }
+  return result;
+};
+
+/**
+ * Load all alert computations from calculations package
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Array>} Array of alert type objects with metadata
+ */
+async function loadAlertTypesFromManifest(logger) {
+  try {
+    // Import calculations the same way index.js does
+    const { calculations } = require('aiden-shared-calculations-unified');
+    const calculationsArray = flattenCalculations(calculations);
+    
+    const alertTypes = [];
+    
+    // Iterate through all computation classes (same logic as index.js alert trigger registration)
+    for (const CalcClass of calculationsArray) {
+      if (!CalcClass || typeof CalcClass.getMetadata !== 'function') {
+        continue;
+      }
+      
+      const metadata = CalcClass.getMetadata();
+      
+      // Check if this is an alert computation
+      if (metadata.isAlertComputation !== true) {
+        continue;
+      }
+      
+      // Check if alert metadata exists
+      if (!metadata.alert) {
+        logger?.log('WARN', `[AlertManifestLoader] Computation ${metadata.name} has isAlertComputation=true but no alert metadata`);
+        continue;
+      }
+      
+      // Build alert type object
+      const alertType = {
+        id: metadata.alert.id,
+        name: metadata.alert.frontendName,
+        description: metadata.alert.description,
+        computationName: metadata.name,
+        category: metadata.category || 'alerts',
+        messageTemplate: metadata.alert.messageTemplate,
+        severity: metadata.alert.severity || 'medium',
+        configKey: metadata.alert.configKey,
+        isTest: metadata.isTest === true,
+        enabled: true
+      };
+      
+      alertTypes.push(alertType);
+      
+      logger?.log('DEBUG', `[AlertManifestLoader] Loaded alert type: ${alertType.id} from ${metadata.name}`);
+    }
+    
+    logger?.log('INFO', `[AlertManifestLoader] Successfully loaded ${alertTypes.length} alert types from calculations`);
+    
+    return alertTypes;
+  } catch (error) {
+    logger?.log('ERROR', `[AlertManifestLoader] Failed to load alert types: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Get alert type by computation name
+ * @param {Array} alertTypes - Array of alert types from loadAlertTypesFromManifest
+ * @param {string} computationName - Name of computation
+ * @returns {Object|null} Alert type object or null
+ */
+function getAlertTypeByComputation(alertTypes, computationName) {
+  return alertTypes.find(type => type.computationName === computationName) || null;
+}
+
+/**
+ * Check if a computation is an alert computation
+ * @param {Array} alertTypes - Array of alert types from loadAlertTypesFromManifest
+ * @param {string} computationName - Name of computation
+ * @returns {boolean} True if computation is an alert
+ */
+function isAlertComputation(alertTypes, computationName) {
+  return getAlertTypeByComputation(alertTypes, computationName) !== null;
+}
+
+/**
+ * Generate alert message from template and metadata
+ * @param {Object} alertType - Alert type object
+ * @param {string} piUsername - PI username
+ * @param {Object} metadata - Metadata from computation results
+ * @returns {string} Generated alert message
+ */
+function generateAlertMessage(alertType, piUsername, metadata = {}) {
+  let message = alertType.messageTemplate;
+  
+  // Replace placeholders
+  message = message.replace(/{piUsername}/g, piUsername || 'Unknown');
+  message = message.replace(/{count}/g, metadata.count || metadata.positions?.length || metadata.moveCount || 0);
+  message = message.replace(/{change}/g, metadata.change || metadata.changePercent || metadata.diff || 'N/A');
+  message = message.replace(/{previous}/g, metadata.previous || metadata.previousValue || metadata.prev || metadata.previousRisk || 'N/A');
+  message = message.replace(/{current}/g, metadata.current || metadata.currentValue || metadata.curr || metadata.currentRisk || 'N/A');
+  message = message.replace(/{sectorName}/g, metadata.sectorName || (metadata.newExposures && metadata.newExposures.length > 0 ? metadata.newExposures.join(', ') : 'Unknown'));
+  message = message.replace(/{ticker}/g, metadata.ticker || metadata.symbol || 'Unknown');
+  
+  // Format numeric values
+  message = message.replace(/{volatility}/g, metadata.volatility ? `${(metadata.volatility * 100).toFixed(1)}` : 'N/A');
+  message = message.replace(/{threshold}/g, metadata.threshold ? `${(metadata.threshold * 100).toFixed(0)}` : 'N/A');
+  message = message.replace(/{diff}/g, metadata.diff ? `${metadata.diff.toFixed(1)}` : 'N/A');
+  message = message.replace(/{prev}/g, metadata.prev ? `${metadata.prev.toFixed(1)}` : 'N/A');
+  message = message.replace(/{curr}/g, metadata.curr ? `${metadata.curr.toFixed(1)}` : 'N/A');
+  message = message.replace(/{title}/g, metadata.title || 'New Update');
+  
+  // Probe placeholders
+  message = message.replace(/{status}/g, metadata.status || 'Unknown Status');
+  message = message.replace(/{timestamp}/g, metadata.timestamp || new Date().toISOString());
+
+  // Behavioral Anomaly placeholders
+  message = message.replace(/{primaryDriver}/g, metadata.primaryDriver || 'Unknown Factor');
+  message = message.replace(/{driverSignificance}/g, metadata.driverSignificance || 'N/A');
+  message = message.replace(/{anomalyScore}/g, metadata.anomalyScore || 'N/A');
+  
+  // Handle positions list if available
+  if (metadata.positions && Array.isArray(metadata.positions) && metadata.positions.length > 0) {
+    const positionsList = metadata.positions
+      .slice(0, 3)
+      .map(p => p.ticker || p.instrumentId)
+      .join(', ');
+    message = message.replace(/{positions}/g, positionsList);
+  }
+  
+  // Handle moves array for PositionInvestedIncrease
+  if (metadata.moves && Array.isArray(metadata.moves) && metadata.moves.length > 0) {
+    const firstMove = metadata.moves[0];
+    message = message.replace(/{symbol}/g, firstMove.symbol || 'Unknown');
+    message = message.replace(/{diff}/g, firstMove.diff ? `${firstMove.diff.toFixed(1)}` : 'N/A');
+    message = message.replace(/{prev}/g, firstMove.prev ? `${firstMove.prev.toFixed(1)}` : 'N/A');
+    message = message.replace(/{curr}/g, firstMove.curr ? `${firstMove.curr.toFixed(1)}` : 'N/A');
+  }
+  
+  return message;
+}
+
+module.exports = {
+  loadAlertTypesFromManifest,
+  getAlertTypeByComputation,
+  isAlertComputation,
+  generateAlertMessage
+};

package/functions/alert-system/index.js

@@ -1,11 +1,15 @@
 /**
  * @fileoverview Alert System Trigger Handler
  * Can be triggered via Pub/Sub when computation results are written
+ * [UPDATED] Now uses dynamic manifest loading instead of hardcoded registry
  */
 
-const { getAlertTypeByComputation, isAlertComputation } = require('./helpers/alert_type_registry');
+const { loadAlertTypesFromManifest, getAlertTypeByComputation, isAlertComputation } = require('./helpers/alert_manifest_loader');
 const { processAlertForPI, readComputationResults, readComputationResultsWithShards } = require('./helpers/alert_helpers');
 
+// Cache for loaded alert types (loaded once per function instance)
+let cachedAlertTypes = null;
+
 /**
  * Pub/Sub trigger handler for alert generation
  * Expected message format:
@@ -19,6 +23,11 @@ async function handleAlertTrigger(message, context, config, dependencies) {
   const { db, logger } = dependencies;
   
   try {
+    // [NEW] Load alert types from manifest (cached)
+    if (!cachedAlertTypes) {
+      cachedAlertTypes = await loadAlertTypesFromManifest(logger);
+    }
+    
     // Parse Pub/Sub message
     let payload;
     if (message.data) {
@@ -35,13 +44,13 @@ async function handleAlertTrigger(message, context, config, dependencies) {
       return;
     }
     
-    // 1. Check if this is an alert computation
-    if (!isAlertComputation(computationName)) {
+    // 1. Check if this is an alert computation (using dynamic manifest)
+    if (!isAlertComputation(cachedAlertTypes, computationName)) {
       logger.log('DEBUG', `[AlertTrigger] Not an alert computation: ${computationName}`);
       return;
     }
     
-    const alertType = getAlertTypeByComputation(computationName);
+    const alertType = getAlertTypeByComputation(cachedAlertTypes, computationName);
     if (!alertType) {
       logger.log('WARN', `[AlertTrigger] Alert type not found for computation: ${computationName}`);
       return;
@@ -101,7 +110,7 @@ async function handleAlertTrigger(message, context, config, dependencies) {
           alertType,
           piMetadata,
           date,
-          dependencies
+          { ...dependencies, alertType } // Pass alertType in dependencies for isTest check
         );
         processedCount++;
       } catch (error) {
@@ -134,47 +143,55 @@ async function handleAlertTrigger(message, context, config, dependencies) {
  */
 async function handleComputationResultWrite(change, context, config, dependencies) {
   const { db, logger } = dependencies;
+  
+  // Declare variables outside try block for error logging
+  let date, category, computationName;
 
-  // --- PATH RESOLUTION LOGIC ---
-  // 1. Try to use context.params (Preferred for Gen 2 & Wildcards)
-  // The 'contextShim' in your root index.js passes 'event.params' into here.
-  let { date, category, computationName } = context.params || {};
+  try {
+    // [NEW] Load alert types from manifest (cached)
+    if (!cachedAlertTypes) {
+      cachedAlertTypes = await loadAlertTypesFromManifest(logger);
+    }
 
-  // 2. Fallback: Parse from resource string (Legacy / Backup)
-  if (!date || !computationName) {
-      const resource = context.resource || (change.after && change.after.ref.path) || '';
-      
-      // Simple split logic can fail on full resource URIs (e.g. //firestore.googleapis.com/...)
-      // so we look for specific keywords to anchor the split.
-      const pathParts = resource.split('/');
-      
-      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) {
-          date = pathParts[dateIndex];
-          category = pathParts[categoryIndex];
-          computationName = pathParts[computationIndex];
-      }
-  }
+    // --- PATH RESOLUTION LOGIC ---
+    // 1. Try to use context.params (Preferred for Gen 2 & Wildcards)
+    // The 'contextShim' in your root index.js passes 'event.params' into here.
+    ({ date, category, computationName } = context.params || {});
+
+    // 2. Fallback: Parse from resource string (Legacy / Backup)
+    if (!date || !computationName) {
+        const resource = context.resource || (change.after && change.after.ref.path) || '';
+        
+        // Simple split logic can fail on full resource URIs (e.g. //firestore.googleapis.com/...)
+        // so we look for specific keywords to anchor the split.
+        const pathParts = resource.split('/');
+        
+        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) {
+            date = pathParts[dateIndex];
+            category = pathParts[categoryIndex];
+            computationName = pathParts[computationIndex];
+        }
+    }
 
-  // 3. Validation
-  if (!date || !category || !computationName) {
-      logger.log('WARN', `[AlertTrigger] Could not resolve path params. Resource: ${context.resource}`);
+    // 3. Validation
+    if (!date || !category || !computationName) {
+        logger.log('WARN', `[AlertTrigger] Could not resolve path params. Resource: ${context.resource}`);
+        return;
+    }
+    
+    // Only process if document was created or updated (not deleted)
+    if (!change.after.exists) {
+      logger.log('INFO', `[AlertTrigger] Document deleted, skipping: ${computationName} for ${date}`);
       return;
-  }
-  
-  // Only process if document was created or updated (not deleted)
-  if (!change.after.exists) {
-    logger.log('INFO', `[AlertTrigger] Document deleted, skipping: ${computationName} for ${date}`);
-    return;
-  }
-  
-  try {
-    // 1. Check if this is an alert computation OR PopularInvestorProfileMetrics
+    }
+    
+    // 1. Check if this is an alert computation OR PopularInvestorProfileMetrics (using dynamic manifest)
     const isProfileMetrics = computationName === 'PopularInvestorProfileMetrics';
-    if (!isAlertComputation(computationName) && !isProfileMetrics) {
+    if (!isAlertComputation(cachedAlertTypes, computationName) && !isProfileMetrics) {
       logger.log('DEBUG', `[AlertTrigger] Not an alert computation or profile metrics: ${computationName}`);
       return;
     }
@@ -195,13 +212,18 @@ async function handleComputationResultWrite(change, context, config, dependencie
       return; // Don't process as alert computation
     }
     
-    const alertType = getAlertTypeByComputation(computationName);
+    const alertType = getAlertTypeByComputation(cachedAlertTypes, computationName);
     if (!alertType) {
       logger.log('WARN', `[AlertTrigger] Alert type not found for computation: ${computationName}`);
       return;
     }
     
-    logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
+    // [NEW] Filter test alerts - only send to developers if isTest === true
+    if (alertType.isTest) {
+      logger.log('INFO', `[AlertTrigger] Processing TEST alert computation: ${computationName} for date ${date} (will only send to developers)`);
+    } else {
+      logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
+    }
     
     // 2. Read and decompress computation results (handling GCS, shards, and compression)
     const docData = change.after.data();
@@ -233,7 +255,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
           alertType,
           piMetadata,
           date,
-          dependencies
+          { ...dependencies, alertType } // Pass alertType in dependencies for isTest check
         );
         processedCount++;
       } catch (error) {

package/functions/api-v2/routes/alerts.js

@@ -6,9 +6,11 @@ const {
     fetchAlertTypes,
     getUserSubscriptions,
     updateSubscription,
-    unsubscribeFromAlerts
+    unsubscribeFromAlerts,
+    isDeveloper
 } = require('../helpers/data-fetchers/firestore.js');
 const { sanitizeCid, sanitizeDocId, validateBatchSize } = require('../helpers/security_utils.js');
+const { loadAlertTypesFromManifest } = require('../../alert-system/helpers/alert_manifest_loader');
 
 const router = express.Router();
 
@@ -34,6 +36,43 @@ const updateSubscriptionSchema = z.object({
     thresholds: z.record(z.any()).optional()
 });
 
+// [NEW] GET /alerts/types - Dynamically load available alert types from manifest
+router.get('/types', async (req, res, next) => {
+    try {
+        const { db, logger } = req.dependencies;
+        
+        // Load alert types from manifest
+        const alertTypes = await loadAlertTypesFromManifest(logger);
+        
+        // Check if user is a developer
+        const isDev = await isDeveloper(db, String(req.targetUserId));
+        
+        // Filter out test alerts for non-developers
+        const filteredAlertTypes = isDev 
+            ? alertTypes 
+            : alertTypes.filter(type => !type.isTest);
+        
+        // Format response for frontend
+        const formattedTypes = filteredAlertTypes.map(type => ({
+            id: type.id,
+            name: type.name,
+            description: type.description,
+            severity: type.severity,
+            configKey: type.configKey,
+            isTest: type.isTest || false
+        }));
+        
+        res.json({ 
+            success: true, 
+            alertTypes: formattedTypes,
+            count: formattedTypes.length 
+        });
+    } catch (error) {
+        logger?.log('ERROR', `[GET /alerts/types] Error loading alert types: ${error.message}`);
+        next(error);
+    }
+});
+
 // GET /alerts/history
 router.get('/history', async (req, res, next) => {
     try {

package/package.json

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