bulltrackers-module 1.0.688 → 1.0.689

package/functions/api-v2/helpers/data-fetchers/firestore.js

@@ -3026,6 +3026,161 @@ const getWatchlistTriggerCounts = async (db, userId, watchlistId) => {
     }
 };
 
+/**
+ * Query PIs matching dynamic watchlist criteria
+ * @param {Object} db - Firestore instance
+ * @param {string} computationName - Name of the computation to query
+ * @param {Object} conditions - Threshold conditions to filter by
+ * @param {string} timeRange - Time range (today, last_7_days, last_30_days, all_time)
+ * @param {number} limit - Maximum number of results
+ * @returns {Promise<Object>} Matching PIs with their values
+ */
+const queryDynamicWatchlistMatches = async (db, computationName, conditions = {}, timeRange = 'last_7_days', limit = 100) => {
+    try {
+        const { readComputationResultsWithShards } = require('../../alert-system/helpers/alert_helpers');
+        
+        // Determine date range based on timeRange
+        const endDate = new Date();
+        const startDate = new Date();
+        
+        switch (timeRange) {
+            case 'today':
+                // Just today
+                break;
+            case 'last_7_days':
+                startDate.setDate(startDate.getDate() - 7);
+                break;
+            case 'last_30_days':
+                startDate.setDate(startDate.getDate() - 30);
+                break;
+            case 'all_time':
+                startDate.setDate(startDate.getDate() - 365); // Max 1 year lookback
+                break;
+            default:
+                startDate.setDate(startDate.getDate() - 7);
+        }
+        
+        // Build list of dates to query
+        const dates = [];
+        for (let d = new Date(endDate); d >= startDate; d.setDate(d.getDate() - 1)) {
+            dates.push(d.toISOString().split('T')[0]);
+        }
+        
+        const matchingPIs = new Map(); // cid -> { matchValue, matchedAt, metadata }
+        
+        // Query each date until we find results
+        for (const dateStr of dates) {
+            try {
+                const docRef = db.collection('unified_insights')
+                    .doc(dateStr)
+                    .collection('results')
+                    .doc('alerts')
+                    .collection('computations')
+                    .doc(computationName);
+                
+                const docSnapshot = await docRef.get();
+                
+                if (!docSnapshot.exists) continue;
+                
+                const docData = docSnapshot.data();
+                const results = await readComputationResultsWithShards(db, docData, docRef, null);
+                
+                if (!results.cids || results.cids.length === 0) continue;
+                
+                // Process each PI
+                for (const piCid of results.cids) {
+                    // Skip if already processed
+                    if (matchingPIs.has(piCid)) continue;
+                    
+                    const piData = results.perUserData?.[piCid] || results.metadata || {};
+                    
+                    // Apply condition filtering
+                    let passesConditions = true;
+                    let matchValue = 0;
+                    
+                    // Extract match value based on computation type
+                    if (piData.change !== undefined) {
+                        matchValue = piData.change;
+                    } else if (piData.current !== undefined) {
+                        matchValue = piData.current;
+                    } else if (piData.riskScore !== undefined) {
+                        matchValue = piData.riskScore;
+                    } else if (piData.volatility !== undefined) {
+                        matchValue = piData.volatility * 100; // Convert to percentage
+                    } else if (piData.diff !== undefined) {
+                        matchValue = piData.diff;
+                    }
+                    
+                    // Apply threshold conditions
+                    if (conditions.minValue !== undefined && matchValue < conditions.minValue) {
+                        passesConditions = false;
+                    }
+                    if (conditions.maxValue !== undefined && matchValue > conditions.maxValue) {
+                        passesConditions = false;
+                    }
+                    
+                    if (passesConditions) {
+                        // Get PI username from master list
+                        let username = piData.piUsername || piData.username || `PI-${piCid}`;
+                        try {
+                            const piProfile = await fetchPopularInvestorMasterList(db, String(piCid));
+                            if (piProfile && piProfile.username) {
+                                username = piProfile.username;
+                            }
+                        } catch (e) {
+                            // Use default username
+                        }
+                        
+                        matchingPIs.set(piCid, {
+                            cid: Number(piCid),
+                            username,
+                            matchedAt: dateStr,
+                            matchValue,
+                            previousValue: piData.previous || piData.prev,
+                            trend: piData.previous !== undefined 
+                                ? (matchValue > piData.previous ? 'up' : matchValue < piData.previous ? 'down' : 'stable')
+                                : undefined,
+                            metadata: {
+                                ...piData,
+                                computationDate: dateStr
+                            }
+                        });
+                        
+                        // Stop if we've hit the limit
+                        if (matchingPIs.size >= limit) break;
+                    }
+                }
+                
+                // Break out of date loop if we have enough results
+                if (matchingPIs.size >= limit) break;
+                
+            } catch (dateErr) {
+                console.warn(`Error processing date ${dateStr} for dynamic watchlist: ${dateErr.message}`);
+                continue;
+            }
+        }
+        
+        // Sort by match value (descending) and return
+        const sortedMatches = Array.from(matchingPIs.values())
+            .sort((a, b) => Math.abs(b.matchValue) - Math.abs(a.matchValue))
+            .slice(0, limit);
+        
+        return {
+            success: true,
+            matches: sortedMatches,
+            count: sortedMatches.length,
+            dateRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            computationName
+        };
+    } catch (error) {
+        console.error(`Error querying dynamic watchlist matches: ${error}`);
+        throw error;
+    }
+};
+
 /**
  * Subscribe to all PIs in a watchlist
  */
@@ -3138,5 +3293,6 @@ module.exports = {
     updateSubscription,
     unsubscribeFromAlerts,
     getWatchlistTriggerCounts,
-    subscribeToAllWatchlistPIs
+    subscribeToAllWatchlistPIs,
+    queryDynamicWatchlistMatches
 };

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

@@ -10,7 +10,8 @@ const {
     autoGenerateWatchlist,
     fetchPopularInvestorMasterList,
     getWatchlistTriggerCounts,
-    subscribeToAllWatchlistPIs
+    subscribeToAllWatchlistPIs,
+    queryDynamicWatchlistMatches
 } = require('../helpers/data-fetchers/firestore.js');
 const { sanitizeDocId } = require('../helpers/security_utils.js');
 
@@ -37,6 +38,16 @@ const watchlistSubscribeSchema = z.object({
     thresholds: z.record(z.any()).optional()
 });
 
+const dynamicMatchesSchema = z.object({
+    computationName: z.string().min(1).max(200),
+    conditions: z.object({
+        minValue: z.number().optional(),
+        maxValue: z.number().optional()
+    }).optional(),
+    timeRange: z.enum(['today', 'last_7_days', 'last_30_days', 'all_time']).optional(),
+    limit: z.number().int().min(1).max(500).optional()
+});
+
 // GET /watchlists/all
 router.get('/all', async (req, res, next) => {
     try {
@@ -217,4 +228,77 @@ router.post('/:id/subscribe-all', async (req, res, next) => {
     }
 });
 
+// POST /watchlists/dynamic/query - Query PIs matching dynamic watchlist criteria
+router.post('/dynamic/query', async (req, res, next) => {
+    try {
+        // Validate input
+        const validatedData = dynamicMatchesSchema.parse(req.body);
+        
+        const { db } = req.dependencies;
+        const result = await queryDynamicWatchlistMatches(
+            db,
+            validatedData.computationName,
+            validatedData.conditions || {},
+            validatedData.timeRange || 'last_7_days',
+            validatedData.limit || 100
+        );
+        
+        res.json(result);
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            return res.status(400).json({ 
+                success: false,
+                error: 'Invalid input', 
+                details: error.errors 
+            });
+        }
+        next(error);
+    }
+});
+
+// GET /watchlists/:id/dynamic/matches - Get current matches for a dynamic watchlist
+router.get('/:id/dynamic/matches', async (req, res, next) => {
+    try {
+        const { db } = req.dependencies;
+        const id = sanitizeDocId(req.params.id);
+        
+        // Fetch the watchlist to get its dynamic config
+        const watchlist = await latestUserCentricSnapshot(db, req.targetUserId, 'watchlists', 'watchlist', 'SignedInUsers', id);
+        
+        if (!watchlist) {
+            const error = new Error("Watchlist not found");
+            error.status = 404;
+            return next(error);
+        }
+        
+        if (watchlist.type !== 'dynamic') {
+            return res.status(400).json({
+                success: false,
+                error: 'This endpoint is only for dynamic watchlists'
+            });
+        }
+        
+        const dynamicConfig = watchlist.dynamicConfig || {};
+        const result = await queryDynamicWatchlistMatches(
+            db,
+            dynamicConfig.computationName,
+            dynamicConfig.parameters || {},
+            dynamicConfig.timeRange || 'last_7_days',
+            100
+        );
+        
+        res.json({
+            success: true,
+            watchlistId: id,
+            watchlistName: watchlist.name,
+            ...result
+        });
+    } catch (error) {
+        if (error.message === "Watchlist not found") {
+            error.status = 404;
+        }
+        next(error);
+    }
+});
+
 module.exports = router;

package/package.json

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