bulltrackers-module 1.0.683 → 1.0.685

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

@@ -7,7 +7,8 @@ const { FieldValue } = require('@google-cloud/firestore');
 const zlib = require('zlib');
 const { Storage } = require('@google-cloud/storage');
 const { generateAlertMessage } = require('./alert_manifest_loader');
-// [UPDATED] Now uses dynamic manifest loading instead of hardcoded registry
+const { evaluateDynamicConditions } = require('./dynamic_evaluator');
+// [UPDATED] Now uses dynamic manifest loading and condition evaluation
 
 const storage = new Storage(); // Singleton GCS Client
 
@@ -97,6 +98,36 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
         // Continue anyway - fail open for important alerts
       }
       
+      // [NEW] Evaluate dynamic conditions based on user's subscription mode
+      // Check if user is a developer for bypass
+      const { isDeveloper } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+      const isDev = await isDeveloper(db, String(userCid));
+      
+      // Get user's configuration from subscription
+      const userDynamicConfig = subscription.dynamicConfig?.[alertType.configKey] || {};
+      const userUseDynamic = subscription.useDynamic?.[alertType.configKey] === true;
+      
+      // Evaluate conditions (will pass if static mode or no conditions)
+      const evaluation = evaluateDynamicConditions(
+        alertType,
+        computationMetadata,
+        userDynamicConfig,
+        userUseDynamic,
+        isDev,
+        logger
+      );
+      
+      if (!evaluation.passes) {
+        logger.log('DEBUG', `[processAlertForPI] User ${userCid} dynamic conditions not met for ${alertType.id}: ${evaluation.reason}`);
+        continue; // Skip this user
+      }
+      
+      if (evaluation.developerBypass) {
+        logger.log('INFO', `[processAlertForPI] Developer ${userCid} bypass: ${evaluation.reason}`);
+      } else {
+        logger.log('DEBUG', `[processAlertForPI] User ${userCid} alert ${alertType.id} in ${evaluation.mode} mode`);
+      }
+      
       const notificationId = `alert_${Date.now()}_${userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
       
       const notificationData = {

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

@@ -0,0 +1,279 @@
+/**
+ * @fileoverview Dynamic Alert Condition Evaluator
+ * Evaluates user-specific thresholds and conditions for dynamic alerts
+ */
+
+/**
+ * Evaluate if an alert result meets user's dynamic thresholds and conditions
+ * @param {Object} alertType - Alert type metadata (with isDynamic, dynamicConfig)
+ * @param {Object} alertResult - Result from computation for specific PI
+ * @param {Object} userDynamicConfig - User's threshold/condition overrides from subscription
+ * @param {boolean} userUseDynamic - Whether user is using dynamic mode for THIS alert
+ * @param {boolean} isDeveloper - Whether user is a developer (bypass conditions)
+ * @param {Object} logger - Logger instance
+ * @returns {Object} { passes: boolean, reason: string, effectiveConfig: Object }
+ */
+function evaluateDynamicConditions(alertType, alertResult, userDynamicConfig, userUseDynamic, isDeveloper, logger) {
+    // Check if alert type supports dynamic configs
+    const supportsDynamic = alertType.isDynamic === true;
+    
+    // If alert doesn't support dynamic OR user chose static mode, always pass
+    if (!supportsDynamic || !userUseDynamic) {
+        return {
+            passes: true,
+            reason: !supportsDynamic 
+                ? 'Alert type does not support dynamic conditions' 
+                : 'User using static mode (no conditions)',
+            effectiveConfig: null,
+            mode: 'static'
+        };
+    }
+
+    // Developer bypass: always pass but log what conditions were met
+    if (isDeveloper) {
+        const metConditions = evaluateConditionsInternal(alertType, alertResult, userDynamicConfig, logger);
+        return {
+            passes: true,
+            reason: `Developer bypass - would have ${metConditions.passes ? 'passed' : 'failed'}: ${metConditions.reason}`,
+            effectiveConfig: metConditions.effectiveConfig,
+            developerBypass: true,
+            mode: 'dynamic-dev-bypass'
+        };
+    }
+
+    // Normal dynamic evaluation
+    const result = evaluateConditionsInternal(alertType, alertResult, userDynamicConfig, logger);
+    return {
+        ...result,
+        mode: 'dynamic'
+    };
+}
+
+/**
+ * Internal condition evaluation logic
+ */
+function evaluateConditionsInternal(alertType, alertResult, userDynamicConfig, logger) {
+    const dynamicConfig = alertType.dynamicConfig || {};
+    const thresholds = dynamicConfig.thresholds || [];
+    const conditions = dynamicConfig.conditions || [];
+    const resultFields = dynamicConfig.resultFields || {};
+    
+    // Build effective configuration (user overrides + defaults)
+    const effectiveConfig = {
+        thresholds: {},
+        conditions: {}
+    };
+    
+    // Apply threshold defaults and user overrides
+    thresholds.forEach(threshold => {
+        const userValue = userDynamicConfig?.thresholds?.[threshold.key];
+        effectiveConfig.thresholds[threshold.key] = userValue !== undefined ? userValue : threshold.default;
+    });
+    
+    // Apply condition defaults and user overrides
+    conditions.forEach(condition => {
+        const userValue = userDynamicConfig?.conditions?.[condition.key];
+        effectiveConfig.conditions[condition.key] = userValue !== undefined ? userValue : condition.default;
+    });
+    
+    // Evaluate each threshold
+    for (const threshold of thresholds) {
+        const thresholdValue = effectiveConfig.thresholds[threshold.key];
+        const result = evaluateThreshold(threshold, thresholdValue, alertResult, resultFields, logger);
+        
+        if (!result.passes) {
+            return {
+                passes: false,
+                reason: result.reason,
+                effectiveConfig
+            };
+        }
+    }
+    
+    // Evaluate each condition
+    for (const condition of conditions) {
+        const conditionValue = effectiveConfig.conditions[condition.key];
+        const result = evaluateCondition(condition, conditionValue, alertResult, resultFields, logger);
+        
+        if (!result.passes) {
+            return {
+                passes: false,
+                reason: result.reason,
+                effectiveConfig
+            };
+        }
+    }
+    
+    // All conditions passed
+    return {
+        passes: true,
+        reason: 'All dynamic conditions met',
+        effectiveConfig
+    };
+}
+
+/**
+ * Evaluate a single threshold
+ */
+function evaluateThreshold(threshold, thresholdValue, alertResult, resultFields, logger) {
+    const key = threshold.key;
+    
+    // Special handling for specific threshold types
+    switch (key) {
+        case 'minChange':
+        case 'minChangeAmount': {
+            const changeField = resultFields.change || 'change';
+            const actualChange = Math.abs(alertResult[changeField] || 0);
+            
+            if (actualChange < thresholdValue) {
+                return {
+                    passes: false,
+                    reason: `Change ${actualChange.toFixed(2)} is below threshold ${thresholdValue}`
+                };
+            }
+            return { passes: true };
+        }
+        
+        case 'minRiskLevel': {
+            const newValueField = resultFields.newValue || 'currentRisk';
+            const actualValue = alertResult[newValueField] || 0;
+            
+            if (actualValue < thresholdValue) {
+                return {
+                    passes: false,
+                    reason: `Risk level ${actualValue.toFixed(2)} is below threshold ${thresholdValue}`
+                };
+            }
+            return { passes: true };
+        }
+        
+        case 'volatilityThreshold': {
+            const volatilityField = resultFields.volatility || 'volatility';
+            const actualVolatility = alertResult[volatilityField] || 0;
+            
+            if (actualVolatility < thresholdValue) {
+                return {
+                    passes: false,
+                    reason: `Volatility ${actualVolatility.toFixed(1)}% is below threshold ${thresholdValue}%`
+                };
+            }
+            return { passes: true };
+        }
+        
+        case 'minIncrease':
+        case 'minIncreasePercentage': {
+            // For position increases, check if ANY move exceeds threshold
+            const moves = alertResult.moves || [];
+            const hasSignificantMove = moves.some(move => Math.abs(move.diff || 0) >= thresholdValue);
+            
+            if (!hasSignificantMove) {
+                return {
+                    passes: false,
+                    reason: `No position increase exceeds threshold ${thresholdValue}pp`
+                };
+            }
+            return { passes: true };
+        }
+        
+        case 'anomalyScoreThreshold': {
+            const scoreField = resultFields.score || 'anomalyScore';
+            const actualScore = alertResult[scoreField] || 0;
+            
+            if (actualScore < thresholdValue) {
+                return {
+                    passes: false,
+                    reason: `Anomaly score ${actualScore.toFixed(2)} is below threshold ${thresholdValue}`
+                };
+            }
+            return { passes: true };
+        }
+        
+        default:
+            logger?.log('WARN', `[DynamicEvaluator] Unknown threshold type: ${key}`);
+            return { passes: true }; // Unknown thresholds pass by default
+    }
+}
+
+/**
+ * Evaluate a single condition
+ */
+function evaluateCondition(condition, conditionValue, alertResult, resultFields, logger) {
+    const key = condition.key;
+    
+    // If condition array is empty, pass (means "all")
+    if (Array.isArray(conditionValue) && conditionValue.length === 0) {
+        return { passes: true };
+    }
+    
+    switch (key) {
+        case 'watchedSectors': {
+            // Check if any new sector is in the watched list
+            const newSectors = alertResult.newExposures || [];
+            const watchedSectors = Array.isArray(conditionValue) ? conditionValue : [];
+            
+            if (watchedSectors.length === 0) {
+                return { passes: true }; // No filter = all sectors
+            }
+            
+            const hasWatchedSector = newSectors.some(sector => 
+                watchedSectors.includes(sector)
+            );
+            
+            if (!hasWatchedSector) {
+                return {
+                    passes: false,
+                    reason: `New sectors [${newSectors.join(', ')}] not in watched list`
+                };
+            }
+            return { passes: true };
+        }
+        
+        case 'watchedSymbols': {
+            // Check if any position move involves a watched symbol
+            const moves = alertResult.moves || [];
+            const watchedSymbols = Array.isArray(conditionValue) ? conditionValue : [];
+            
+            if (watchedSymbols.length === 0) {
+                return { passes: true }; // No filter = all symbols
+            }
+            
+            const hasWatchedSymbol = moves.some(move => 
+                watchedSymbols.includes(move.symbol)
+            );
+            
+            if (!hasWatchedSymbol) {
+                return {
+                    passes: false,
+                    reason: `Position changes not in watched symbols list`
+                };
+            }
+            return { passes: true };
+        }
+        
+        case 'watchedDrivers': {
+            // Check if primary driver is in watched list
+            const primaryDriver = alertResult.primaryDriver || '';
+            const watchedDrivers = Array.isArray(conditionValue) ? conditionValue : [];
+            
+            if (watchedDrivers.length === 0) {
+                return { passes: true }; // No filter = all drivers
+            }
+            
+            if (!watchedDrivers.includes(primaryDriver)) {
+                return {
+                    passes: false,
+                    reason: `Primary driver '${primaryDriver}' not in watched list`
+                };
+            }
+            return { passes: true };
+        }
+        
+        default:
+            logger?.log('WARN', `[DynamicEvaluator] Unknown condition type: ${key}`);
+            return { passes: true }; // Unknown conditions pass by default
+    }
+}
+
+module.exports = {
+    evaluateDynamicConditions
+};

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

@@ -56,14 +56,22 @@ router.get('/types', async (req, res, next) => {
         
         logger?.log('INFO', `[GET /alerts/types] After filtering: ${filteredAlertTypes.length} alert types (removed ${alertTypes.length - filteredAlertTypes.length} test alerts)`);
         
-        // Format response for frontend
+        // Format response for frontend (include dynamic configuration)
         const formattedTypes = filteredAlertTypes.map(type => ({
             id: type.id,
             name: type.name,
             description: type.description,
             severity: type.severity,
             configKey: type.configKey,
-            isTest: type.isTest || false
+            isTest: type.isTest || false,
+            
+            // [NEW] Include dynamic alert configuration
+            isDynamic: type.isDynamic || false,
+            dynamicConfig: type.isDynamic ? {
+                thresholds: type.dynamicConfig?.thresholds || [],
+                conditions: type.dynamicConfig?.conditions || [],
+                resultFields: type.dynamicConfig?.resultFields || {}
+            } : null
         }));
         
         res.json({ 
@@ -189,25 +197,31 @@ router.get('/types', async (req, res, next) => {
 // GET /alerts/dynamic-watchlist-computations - Get available computations for dynamic watchlists
 router.get('/dynamic-watchlist-computations', async (req, res, next) => {
     try {
-        // Import getAllAlertTypes from alert system
-        const { getAllAlertTypes } = require('../../alert-system/helpers/alert_type_registry.js');
-        const alertTypes = getAllAlertTypes();
+        const { logger } = req.dependencies;
         
-        // Extract unique computations from alert types
-        const computations = alertTypes.map(type => ({
-            computationName: type.computationName,
-            alertTypeName: type.name,
-            description: type.description,
-            severity: type.severity
-        }));
+        // [UPDATED] Load alert types from manifest instead of hardcoded registry
+        const alertTypes = await loadAlertTypesFromManifest(logger);
         
-        // Cache in browser/CDN for 1 hour (static data)
+        // Extract unique computations from alert types (exclude test alerts)
+        const computations = alertTypes
+            .filter(type => !type.isTest)
+            .map(type => ({
+                computationName: type.computationName,
+                alertTypeName: type.name,
+                description: type.description,
+                severity: type.severity,
+                configKey: type.configKey
+            }));
+        
+        // Cache in browser/CDN for 1 hour (data changes infrequently)
         res.set('Cache-Control', 'public, max-age=3600');
         res.json({
             success: true,
-            computations
+            computations,
+            count: computations.length
         });
     } catch (error) {
+        logger?.log('ERROR', `[GET /alerts/dynamic-watchlist-computations] Error: ${error.message}`);
         next(error);
     }
 });

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -680,13 +680,12 @@ async function resolveRoutes(db, date, pass, tasks, logger) {
 
 async function dispatchComputationPass(config, dependencies, computationManifest, reqBody = {}) {
     switch (reqBody.action) {
-        case 'VERIFY': return handlePassVerification(config, dependencies, computationManifest, reqBody);
-        case 'SWEEP': return handleSweepDispatch(config, dependencies, computationManifest, reqBody);
-        case 'REPORT': return handleFinalSweepReporting(config, dependencies, computationManifest, reqBody);
+        case 'VERIFY':    return handlePassVerification(config, dependencies, computationManifest, reqBody);
+        case 'SWEEP':     return handleSweepDispatch(config, dependencies, computationManifest, reqBody);
+        case 'REPORT':    return handleFinalSweepReporting(config, dependencies, computationManifest, reqBody);
         case 'FORCE_RUN': return handleForceRun(config, dependencies, computationManifest, reqBody);
-        // 3. REGISTER SNAPSHOT ACTION
-        case 'SNAPSHOT': return handleSnapshot(config, dependencies, reqBody);
-        default: return handleStandardDispatch(config, dependencies, computationManifest, reqBody);
+        case 'SNAPSHOT':  return handleSnapshot(config, dependencies, reqBody);
+        default:          return handleStandardDispatch(config, dependencies, computationManifest, reqBody);
     }
 }
 

package/package.json

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