bulltrackers-module 1.0.504 → 1.0.506

package/functions/generic-api/user-api/helpers/alerts/subscription_helpers.js

@@ -0,0 +1,327 @@
+/**
+ * @fileoverview Alert Subscription Management Helpers
+ * Handles subscriptions for watchlist alerts (static and dynamic)
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+/**
+ * POST /user/me/subscriptions
+ * Subscribe to alerts for a PI in a watchlist
+ */
+async function subscribeToAlerts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid, watchlistId, piCid, alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !watchlistId || !piCid) {
+        return res.status(400).json({ error: "Missing required fields: userCid, watchlistId, piCid" });
+    }
+    
+    try {
+        // Verify watchlist exists and belongs to user
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(watchlistId);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Verify PI is in the watchlist
+        let piInWatchlist = false;
+        if (watchlistData.type === 'static') {
+            piInWatchlist = watchlistData.items?.some(item => item.cid === Number(piCid));
+        } else if (watchlistData.type === 'dynamic') {
+            // For dynamic watchlists, we'll check if the PI is in the current computation result
+            // This is a simplified check - in production, you'd fetch the latest computation result
+            piInWatchlist = true; // Allow subscriptions for dynamic watchlists
+        }
+        
+        if (!piInWatchlist && watchlistData.type === 'static') {
+            return res.status(400).json({ error: "PI is not in this watchlist" });
+        }
+        
+        // Default alert types (all enabled) if not provided
+        const defaultAlertTypes = {
+            newPositions: true,
+            volatilityChanges: true,
+            increasedRisk: true,
+            newSector: true,
+            increasedPositionSize: true,
+            newSocialPost: true
+        };
+        
+        const subscriptionData = {
+            userCid: Number(userCid),
+            piCid: Number(piCid),
+            watchlistId: watchlistId,
+            alertTypes: alertTypes || defaultAlertTypes,
+            thresholds: thresholds || {},
+            subscribedAt: FieldValue.serverTimestamp(),
+            lastAlertAt: null
+        };
+        
+        // Store subscription
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        await subscriptionRef.set(subscriptionData, { merge: true });
+        
+        logger.log('SUCCESS', `[subscribeToAlerts] User ${userCid} subscribed to alerts for PI ${piCid} in watchlist ${watchlistId}`);
+        
+        return res.status(200).json({
+            success: true,
+            subscription: subscriptionData
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[subscribeToAlerts] Error creating subscription for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * PUT /user/me/subscriptions/:piCid
+ * Update alert subscription settings
+ */
+async function updateSubscription(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { piCid } = req.params;
+    const { alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !piCid) {
+        return res.status(400).json({ error: "Missing userCid or piCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        const subscriptionDoc = await subscriptionRef.get();
+        
+        if (!subscriptionDoc.exists) {
+            return res.status(404).json({ error: "Subscription not found" });
+        }
+        
+        const updates = {};
+        
+        if (alertTypes !== undefined) {
+            updates.alertTypes = alertTypes;
+        }
+        
+        if (thresholds !== undefined) {
+            updates.thresholds = thresholds;
+        }
+        
+        if (Object.keys(updates).length === 0) {
+            return res.status(400).json({ error: "No updates provided" });
+        }
+        
+        updates.updatedAt = FieldValue.serverTimestamp();
+        
+        await subscriptionRef.update(updates);
+        
+        logger.log('SUCCESS', `[updateSubscription] Updated subscription for user ${userCid}, PI ${piCid}`);
+        
+        const updatedDoc = await subscriptionRef.get();
+        return res.status(200).json({
+            success: true,
+            subscription: {
+                id: updatedDoc.id,
+                ...updatedDoc.data()
+            }
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[updateSubscription] Error updating subscription for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * DELETE /user/me/subscriptions/:piCid
+ * Unsubscribe from alerts for a PI
+ */
+async function unsubscribeFromAlerts(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { piCid } = req.params;
+    
+    if (!userCid || !piCid) {
+        return res.status(400).json({ error: "Missing userCid or piCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts')
+            .doc(String(piCid));
+        
+        const subscriptionDoc = await subscriptionRef.get();
+        
+        if (!subscriptionDoc.exists) {
+            return res.status(404).json({ error: "Subscription not found" });
+        }
+        
+        await subscriptionRef.delete();
+        
+        logger.log('SUCCESS', `[unsubscribeFromAlerts] User ${userCid} unsubscribed from alerts for PI ${piCid}`);
+        
+        return res.status(200).json({
+            success: true,
+            message: "Unsubscribed successfully"
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[unsubscribeFromAlerts] Error unsubscribing user ${userCid} from PI ${piCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * GET /user/me/subscriptions
+ * Get all subscriptions for a user
+ */
+async function getUserSubscriptions(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    
+    if (!userCid) {
+        return res.status(400).json({ error: "Missing userCid" });
+    }
+    
+    try {
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionsRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts');
+        
+        const snapshot = await subscriptionsRef.get();
+        
+        const subscriptions = [];
+        snapshot.forEach(doc => {
+            subscriptions.push({
+                piCid: Number(doc.id),
+                ...doc.data()
+            });
+        });
+        
+        return res.status(200).json({
+            subscriptions,
+            count: subscriptions.length
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[getUserSubscriptions] Error fetching subscriptions for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+/**
+ * POST /user/me/watchlists/:id/subscribe-all
+ * Subscribe to all PIs in a watchlist with default alert settings
+ */
+async function subscribeToWatchlist(req, res, dependencies, config) {
+    const { db, logger } = dependencies;
+    const { userCid } = req.query;
+    const { id } = req.params;
+    const { alertTypes, thresholds } = req.body;
+    
+    if (!userCid || !id) {
+        return res.status(400).json({ error: "Missing userCid or watchlist id" });
+    }
+    
+    try {
+        // Get watchlist
+        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+        const watchlistRef = db.collection(watchlistsCollection)
+            .doc(String(userCid))
+            .collection('lists')
+            .doc(id);
+        
+        const watchlistDoc = await watchlistRef.get();
+        
+        if (!watchlistDoc.exists) {
+            return res.status(404).json({ error: "Watchlist not found" });
+        }
+        
+        const watchlistData = watchlistDoc.data();
+        
+        // Default alert types
+        const defaultAlertTypes = alertTypes || {
+            newPositions: true,
+            volatilityChanges: true,
+            increasedRisk: true,
+            newSector: true,
+            increasedPositionSize: true,
+            newSocialPost: true
+        };
+        
+        const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
+        const subscriptionsRef = db.collection(subscriptionsCollection)
+            .doc(String(userCid))
+            .collection('alerts');
+        
+        let subscribedCount = 0;
+        
+        if (watchlistData.type === 'static') {
+            // Subscribe to all PIs in static watchlist
+            const items = watchlistData.items || [];
+            
+            for (const item of items) {
+                const subscriptionData = {
+                    userCid: Number(userCid),
+                    piCid: item.cid,
+                    watchlistId: id,
+                    alertTypes: item.alertConfig || defaultAlertTypes,
+                    thresholds: thresholds || {},
+                    subscribedAt: FieldValue.serverTimestamp(),
+                    lastAlertAt: null
+                };
+                
+                await subscriptionsRef.doc(String(item.cid)).set(subscriptionData, { merge: true });
+                subscribedCount++;
+            }
+        } else if (watchlistData.type === 'dynamic') {
+            // For dynamic watchlists, we'd need to fetch the current computation result
+            // For now, we'll just set up the subscription structure
+            // The actual PIs will be determined when the computation runs
+            logger.log('INFO', `[subscribeToWatchlist] Dynamic watchlist subscription setup for ${id} (will be populated by computation)`);
+        }
+        
+        logger.log('SUCCESS', `[subscribeToWatchlist] Subscribed user ${userCid} to ${subscribedCount} PIs in watchlist ${id}`);
+        
+        return res.status(200).json({
+            success: true,
+            subscribed: subscribedCount,
+            watchlistId: id,
+            watchlistType: watchlistData.type
+        });
+        
+    } catch (error) {
+        logger.log('ERROR', `[subscribeToWatchlist] Error subscribing to watchlist ${id} for user ${userCid}`, error);
+        return res.status(500).json({ error: error.message });
+    }
+}
+
+module.exports = {
+    subscribeToAlerts,
+    updateSubscription,
+    unsubscribeFromAlerts,
+    getUserSubscriptions,
+    subscribeToWatchlist
+};

package/functions/generic-api/user-api/helpers/{test_alert_helpers.js → alerts/test_alert_helpers.js}

@@ -5,7 +5,7 @@
 
 const { FieldValue } = require('@google-cloud/firestore');
 const { getAllAlertTypes, getAlertTypeByComputation } = require('../../../alert-system/helpers/alert_type_registry');
-const { isDeveloperAccount, getDevOverride } = require('./dev_helpers');
+const { isDeveloperAccount, getDevOverride } = require('../dev/dev_helpers');
 
 /**
  * POST /user/dev/test-alert

package/functions/generic-api/user-api/helpers/collection_helpers.js

@@ -1,41 +1,11 @@
 /**
- * @fileoverview Collection Path Helpers
- * Utilities for resolving collection paths using the collection registry
- * and handling CID lookups, dual reads/writes for migration
+ * @fileoverview Collection Path Helpers (Backward Compatibility)
+ * Re-exports from core/path_resolution_helpers.js for backward compatibility
+ * This file maintains the old API while using the new migration-enabled helpers
  */
 
-/**
- * Get eToro CID from Firebase UID
- * @param {Firestore} db - Firestore instance
- * @param {string} firebaseUid - Firebase authentication UID
- * @returns {Promise<number|null>} - eToro CID or null if not found
- */
-async function getCidFromFirebaseUid(db, firebaseUid) {
-    try {
-        const userDoc = await db.collection('signedInUsers').doc(firebaseUid).get();
-        if (!userDoc.exists) return null;
-        const data = userDoc.data();
-        return data.etoroCID || data.cid || null;
-    } catch (error) {
-        console.error('[getCidFromFirebaseUid] Error fetching CID:', error);
-        return null;
-    }
-}
-
-/**
- * Get collection path from registry
- * @param {object} collectionRegistry - Collection registry instance
- * @param {string} category - Registry category (e.g., 'signedInUsers', 'popularInvestors')
- * @param {string} subcategory - Subcategory name (e.g., 'portfolio', 'watchlists')
- * @param {object} params - Dynamic segment values (e.g., { cid: '123', date: '2025-01-01' })
- * @returns {string} - Resolved collection/document path
- */
-function getCollectionPath(collectionRegistry, category, subcategory, params = {}) {
-    if (!collectionRegistry || !collectionRegistry.getCollectionPath) {
-        throw new Error('Collection registry not available or missing getCollectionPath method');
-    }
-    return collectionRegistry.getCollectionPath(category, subcategory, params);
-}
+// Re-export from core helpers for backward compatibility
+const coreHelpers = require('./core/path_resolution_helpers');
 
 /**
  * Extract collection name from a full path
@@ -48,7 +18,8 @@ function extractCollectionName(path) {
 
 /**
  * Dual read helper - tries new structure first, falls back to legacy
- * @param {Firestore} db - Firestore instance
+ * @deprecated Use readWithMigration from core/path_resolution_helpers instead
+ * @param {object} db - Firestore instance
  * @param {string} newPath - New collection path
  * @param {string} legacyPath - Legacy collection path
  * @param {object} [options={}] - Options for reading
@@ -97,7 +68,8 @@ async function readWithFallback(db, newPath, legacyPath, options = {}) {
 
 /**
  * Dual write helper - writes to both new and legacy locations during migration
- * @param {Firestore} db - Firestore instance
+ * @deprecated Use writeWithMigration from core/path_resolution_helpers instead
+ * @param {object} db - Firestore instance
  * @param {string} newPath - New collection path
  * @param {string} legacyPath - Legacy collection path
  * @param {object} data - Data to write
@@ -155,7 +127,7 @@ async function writeDual(db, newPath, legacyPath, data, options = {}) {
  * @returns {string} - Path to latest portfolio snapshot
  */
 function getUserPortfolioPath(collectionRegistry, cid) {
-    return getCollectionPath(collectionRegistry, 'signedInUsers', 'portfolio', { cid: String(cid) });
+    return coreHelpers.getCollectionPath(collectionRegistry, 'signedInUsers', 'portfolio', { cid: String(cid) });
 }
 
 /**
@@ -165,7 +137,7 @@ function getUserPortfolioPath(collectionRegistry, cid) {
  * @returns {string} - Path to latest trade history snapshot
  */
 function getUserTradeHistoryPath(collectionRegistry, cid) {
-    return getCollectionPath(collectionRegistry, 'signedInUsers', 'tradeHistory', { cid: String(cid) });
+    return coreHelpers.getCollectionPath(collectionRegistry, 'signedInUsers', 'tradeHistory', { cid: String(cid) });
 }
 
 /**
@@ -175,7 +147,7 @@ function getUserTradeHistoryPath(collectionRegistry, cid) {
  * @returns {string} - Path to social posts collection
  */
 function getUserSocialPostsPath(collectionRegistry, cid) {
-    return getCollectionPath(collectionRegistry, 'signedInUsers', 'socialPosts', { cid: String(cid) });
+    return coreHelpers.getCollectionPath(collectionRegistry, 'signedInUsers', 'socialPosts', { cid: String(cid) });
 }
 
 /**
@@ -186,7 +158,7 @@ function getUserSocialPostsPath(collectionRegistry, cid) {
  * @returns {string} - Path to date-based portfolio data
  */
 function getRootDataPortfolioPath(collectionRegistry, date, cid) {
-    return getCollectionPath(collectionRegistry, 'rootData', 'signedInUserPortfolio', { date, cid: String(cid) });
+    return coreHelpers.getCollectionPath(collectionRegistry, 'rootData', 'signedInUserPortfolio', { date, cid: String(cid) });
 }
 
 /**
@@ -197,12 +169,13 @@ function getRootDataPortfolioPath(collectionRegistry, date, cid) {
  * @returns {string} - Path to date-based trade history data
  */
 function getRootDataTradeHistoryPath(collectionRegistry, date, cid) {
-    return getCollectionPath(collectionRegistry, 'rootData', 'signedInUserTradeHistory', { date, cid: String(cid) });
+    return coreHelpers.getCollectionPath(collectionRegistry, 'rootData', 'signedInUserTradeHistory', { date, cid: String(cid) });
 }
 
+// Re-export core helpers
 module.exports = {
-    getCidFromFirebaseUid,
-    getCollectionPath,
+    getCidFromFirebaseUid: coreHelpers.getCidFromFirebaseUid,
+    getCollectionPath: coreHelpers.getCollectionPath,
     extractCollectionName,
     readWithFallback,
     writeDual,
@@ -210,6 +183,11 @@ module.exports = {
     getUserTradeHistoryPath,
     getUserSocialPostsPath,
     getRootDataPortfolioPath,
-    getRootDataTradeHistoryPath
+    getRootDataTradeHistoryPath,
+    // Also export new migration helpers
+    readWithMigration: coreHelpers.readWithMigration,
+    writeWithMigration: coreHelpers.writeWithMigration,
+    getNewPath: coreHelpers.getNewPath,
+    getLegacyPath: coreHelpers.getLegacyPath
 };
 

package/functions/generic-api/user-api/helpers/core/compression_helpers.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Compression/Decompression Utilities
+ * Handles decompression of computation results stored as compressed byte strings
+ */
+
+const zlib = require('zlib');
+
+/**
+ * Decompress computation results if they are stored as compressed byte strings
+ * @param {object} data - The raw Firestore document data
+ * @returns {object} The decompressed JSON object or original data if not compressed
+ */
+function tryDecompress(data) {
+    if (data && data._compressed === true && data.payload) {
+        try {
+            let buffer;
+            
+            // Handle different payload types from Firestore
+            if (Buffer.isBuffer(data.payload)) {
+                // Already a Buffer - use directly
+                buffer = data.payload;
+            } else if (typeof data.payload === 'string') {
+                // If it's a string, try base64 first, then direct
+                try {
+                    buffer = Buffer.from(data.payload, 'base64');
+                } catch (e) {
+                    // If not base64, might already be decompressed JSON string
+                    try {
+                        const parsed = JSON.parse(data.payload);
+                        // If parsing succeeds, return it (data was already decompressed)
+                        return parsed;
+                    } catch (e2) {
+                        // Not JSON either, try as raw buffer
+                        buffer = Buffer.from(data.payload);
+                    }
+                }
+            } else {
+                // Try to convert to Buffer
+                buffer = Buffer.from(data.payload);
+            }
+            
+            // Decompress the buffer
+            const decompressed = zlib.gunzipSync(buffer);
+            const jsonString = decompressed.toString('utf8');
+            
+            // Parse the JSON string
+            const parsed = JSON.parse(jsonString);
+            
+            // Verify it's an object, not a string
+            if (typeof parsed === 'string') {
+                // Might be double-encoded JSON string
+                return JSON.parse(parsed);
+            }
+            
+            return parsed;
+        } catch (e) {
+            console.error('[tryDecompress] Decompression failed:', e.message);
+            // Return empty object on failure to avoid crashing
+            return {};
+        }
+    }
+    return data;
+}
+
+module.exports = {
+    tryDecompress
+};
+