bulltrackers-module 1.0.586 → 1.0.588

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

@@ -127,6 +127,8 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
     'NewSectorExposure': 'newSector',
     'PositionInvestedIncrease': 'increasedPositionSize',
     'NewSocialPost': 'newSocialPost',
+    // [NEW] Mapping for BehavioralAnomaly
+    'BehavioralAnomaly': 'behavioralAnomaly',
     'TestSystemProbe': 'increasedRisk' // Hack: Map to 'increasedRisk' key
   };
   
@@ -155,7 +157,9 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
       newSector: true,
       increasedPositionSize: true,
       newSocialPost: true,
-      newPositions: true
+      newPositions: true,
+      // [NEW] Enable for Dev Override
+      behavioralAnomaly: true
     };
     
     // Check all developer accounts
@@ -224,8 +228,8 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
   
   // Step 2: For each user, read their watchlists from SignedInUsers/{cid}/watchlists
   const { readWithMigration } = require('../../generic-api/user-api/helpers/core/path_resolution_helpers');
-  const { collectionRegistry } = dependencies;
-  const config = dependencies.config || {};
+  // const { collectionRegistry } = dependencies; // Already destructured above
+  // const config = dependencies.config || {}; // Already defined
   
   for (const userCidStr of userCids) {
     try {

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

@@ -1,8 +1,6 @@
 /**
- * @fileoverview Alert Type Registry
- * Defines all available alert types and their associated computations
+ * file: alert-system/helpers/alert_type_registry.js
  */
-
 const ALERT_TYPES = {
   increasedRisk: {
     id: 'increasedRisk',
@@ -54,13 +52,25 @@ const ALERT_TYPES = {
     severity: 'low',
     enabled: true
   },
+  // [NEW] Behavioral Anomaly Registration
+  behavioralAnomaly: {
+    id: 'behavioralAnomaly',
+    name: 'Behavioral Anomaly',
+    description: 'Alert when a Popular Investor deviates significantly from their baseline behavior',
+    computationName: 'BehavioralAnomaly',
+    category: 'alerts',
+    // Uses metadata keys from Behaviour.js: primaryDriver, driverSignificance, anomalyScore
+    messageTemplate: 'Behavioral Alert for {piUsername}: {primaryDriver} Deviation ({driverSignificance}) detected.',
+    severity: 'high',
+    enabled: true
+  },
   testSystemProbe: {
     id: 'testSystemProbe',
     name: 'Test System Probe',
     description: 'Always-on debug alert',
-    computationName: 'TestSystemProbe', // Must match the class name above
+    computationName: 'TestSystemProbe',
     category: 'alerts',
-    messageTemplate: 'Probe Triggered for {status} at {timestamp}', // Uses keys from the result object
+    messageTemplate: 'Probe Triggered for {status} at {timestamp}', 
     severity: 'info',
     enabled: true
   },
@@ -113,6 +123,8 @@ function generateAlertMessage(alertType, piUsername, metadata = {}) {
   message = message.replace('{current}', metadata.current || metadata.currentValue || metadata.curr || metadata.currentRisk || 'N/A');
   message = message.replace('{sectorName}', metadata.sectorName || (metadata.newExposures && metadata.newExposures.length > 0 ? metadata.newExposures.join(', ') : 'Unknown'));
   message = message.replace('{ticker}', metadata.ticker || metadata.symbol || 'Unknown');
+  
+  // Format numeric values
   message = message.replace('{volatility}', metadata.volatility ? `${(metadata.volatility * 100).toFixed(1)}` : 'N/A');
   message = message.replace('{threshold}', metadata.threshold ? `${(metadata.threshold * 100).toFixed(0)}` : 'N/A');
   message = message.replace('{diff}', metadata.diff ? `${metadata.diff.toFixed(1)}` : 'N/A');
@@ -120,6 +132,15 @@ function generateAlertMessage(alertType, piUsername, metadata = {}) {
   message = message.replace('{curr}', metadata.curr ? `${metadata.curr.toFixed(1)}` : 'N/A');
   message = message.replace('{title}', metadata.title || 'New Update');
   
+  // [FIX] Probe Placeholders (Missing in original)
+  message = message.replace('{status}', metadata.status || 'Unknown Status');
+  message = message.replace('{timestamp}', metadata.timestamp || new Date().toISOString());
+
+  // [NEW] Behavioral Anomaly Placeholders
+  message = message.replace('{primaryDriver}', metadata.primaryDriver || 'Unknown Factor');
+  message = message.replace('{driverSignificance}', metadata.driverSignificance || 'N/A');
+  message = message.replace('{anomalyScore}', metadata.anomalyScore || 'N/A');
+  
   // Handle positions list if available
   if (metadata.positions && Array.isArray(metadata.positions) && metadata.positions.length > 0) {
     const positionsList = metadata.positions
@@ -148,5 +169,4 @@ module.exports = {
   getAllAlertTypes,
   isAlertComputation,
   generateAlertMessage
-};
-
+};

package/functions/computation-system/data/CachedDataLoader.js

@@ -21,8 +21,7 @@ const {
 const { getAvailabilityWindow } = require('./AvailabilityChecker');
 const zlib = require('zlib'); 
 
-// [NEW] Mapping of Loader Methods to Availability Flags in the Index
-// Used to intelligently skip reads for data that is known to be missing.
+// [NEW] Mapping of Loader Methods to Availability Flags
 const LOADER_DEPENDENCY_MAP = {
     'loadRankings': 'piRankings',
     'loadRatings': 'piRatings',
@@ -30,7 +29,18 @@ const LOADER_DEPENDENCY_MAP = {
     'loadWatchlistMembership': 'watchlistMembership',
     'loadAlertHistory': 'piAlertHistory',
     'loadInsights': 'hasInsights',
-    'loadSocial': 'hasSocial' // broad check covering PI, SignedIn, and Generic
+    'loadSocial': 'hasSocial'
+};
+
+// [NEW] Mapping of Loader Methods to Collection Config Keys / Defaults
+// This allows us to construct references for Batch Reading without executing the opaque loader functions.
+const LOADER_COLLECTION_MAP = {
+    'loadRatings': { configKey: 'piRatingsCollection', default: 'PIRatingsData' },
+    'loadPageViews': { configKey: 'piPageViewsCollection', default: 'PIPageViewsData' },
+    'loadWatchlistMembership': { configKey: 'watchlistMembershipCollection', default: 'WatchlistMembershipData' },
+    'loadAlertHistory': { configKey: 'piAlertHistoryCollection', default: 'PIAlertHistoryData' },
+    'loadInsights': { configKey: 'insightsCollectionName', default: 'daily_instrument_insights' },
+    'loadRankings': { configKey: 'popularInvestorRankingsCollection', default: 'popular_investor_rankings' }
 };
 
 class CachedDataLoader {
@@ -64,7 +74,7 @@ class CachedDataLoader {
         return data;
     }
 
-    // ... [Existing load methods: loadMappings, loadInsights, etc. unchanged] ...
+    // ... [Existing single-day load methods remain unchanged] ...
     async loadMappings() { 
         if (this.cache.mappings) return this.cache.mappings; 
         const { calculationUtils } = this.deps; 
@@ -162,13 +172,12 @@ class CachedDataLoader {
         return data;
     }
 
-    // --- [UPDATED] Series Loading Logic with Pre-flight Availability Check ---
+    // --- [UPDATED] Batched Series Loading Logic ---
     /**
-     * Optimistically loads a series of root data over a lookback period.
-     * Uses the Root Data Index (getAvailabilityWindow) to avoid reading non-existent data.
-     * @param {string} loaderMethod - The method name to call (e.g., 'loadAlertHistory')
-     * @param {string} dateStr - The end date (exclusive or inclusive depending on data availability)
-     * @param {number} lookbackDays - Number of days to look back
+     * Optimistically loads a series of root data over a lookback period using Batch Reads.
+     * 1. Checks Availability Index (Range Query).
+     * 2. Constructs Refs for all existing dates.
+     * 3. Fetches all in ONE db.getAll() request.
      */
     async loadSeries(loaderMethod, dateStr, lookbackDays) {
         if (!this[loaderMethod]) throw new Error(`[CachedDataLoader] Unknown method ${loaderMethod}`);
@@ -176,95 +185,98 @@ class CachedDataLoader {
         // 1. Calculate Date Range
         const endDate = new Date(dateStr);
         const startDate = new Date(endDate);
-        startDate.setUTCDate(startDate.getUTCDate() - (lookbackDays - 1)); // -1 because range is inclusive of end
+        startDate.setUTCDate(startDate.getUTCDate() - (lookbackDays - 1));
         
         const startStr = startDate.toISOString().slice(0, 10);
         const endStr = endDate.toISOString().slice(0, 10);
 
         // 2. Pre-flight: Fetch Availability Window
-        // This is a single range query that tells us exactly which days have data.
         let availabilityMap = new Map();
         try {
             availabilityMap = await getAvailabilityWindow(this.deps, startStr, endStr);
         } catch (e) {
-            console.warn(`[CachedDataLoader] Availability check failed for series. Falling back to optimistic fetch. Error: ${e.message}`);
-            // If availability check fails, we proceed with optimistic fetching (empty map)
+            console.warn(`[CachedDataLoader] Availability check failed for series. Falling back to optimistic batch fetch. Error: ${e.message}`);
         }
 
-        // 3. Identify Required Flag in Availability Index
+        // 3. Identify Collection & Required Flag
+        const collectionInfo = LOADER_COLLECTION_MAP[loaderMethod];
         const requiredFlag = LOADER_DEPENDENCY_MAP[loaderMethod];
         
-        const results = {};
-        const promises = [];
-        let skippedCount = 0;
+        if (!collectionInfo) {
+            // Fallback for methods not in the batch map (use legacy parallel loop)
+            return this._loadSeriesLegacy(loaderMethod, dateStr, lookbackDays);
+        }
+
+        const collectionName = this.config[collectionInfo.configKey] || collectionInfo.default;
+        const batchRefs = [];
+        const dateKeyMap = []; // Keep track of which date corresponds to which ref index
 
-        // 4. Fetch N days back
+        // 4. Build Batch References
         for (let i = 0; i < lookbackDays; i++) {
             const d = new Date(endDate);
             d.setUTCDate(d.getUTCDate() - i);
             const dString = d.toISOString().slice(0, 10);
             
-            // CHECK: Does index exist AND does it have our data?
-            // If map is empty (e.g. error), we default to trying (optimistic) unless we strictly trust the map.
-            // But if the query succeeded, map only contains dates that exist.
+            // Check Availability
             const dayStatus = availabilityMap.get(dString);
-            
-            // Logic:
-            // 1. If dayStatus is undefined, it means the DATE itself is missing from the index (no data at all). -> SKIP
-            // 2. If dayStatus is defined, check the specific flag. -> IF FALSE SKIP
-            
-            // Note: If availabilityMap is empty but dates SHOULD exist, we might have an issue. 
-            // However, getAvailabilityWindow returns only existing docs. So if it's not in map, it's not in DB.
-            
             let shouldFetch = false;
 
             if (availabilityMap.size > 0) {
-                // If we have index data, we trust it.
-                if (dayStatus) {
-                   if (!requiredFlag || dayStatus[requiredFlag]) {
-                       shouldFetch = true;
-                   }
+                // If index exists, trust it
+                if (dayStatus && (!requiredFlag || dayStatus[requiredFlag])) {
+                    shouldFetch = true;
                 }
             } else {
-                // If map is empty, it could mean NO data exists in that range, OR check failed.
-                // If check failed (caught above), we might want to try anyway? 
-                // For now, if map is empty (validly), we assume no data.
-                // To be safe against empty map meaning "everything missing", we can verify if the map was populated.
-                // But getAvailabilityWindow returns a new Map(), so size 0 means 0 results found.
-                // Thus: Skip everything.
-                shouldFetch = false;
+                // If index check failed/empty, try optimistically
+                shouldFetch = true;
             }
 
-            // Fallback for when we didn't run availability check (e.g. no deps provided or import fail)?
-            // The availabilityMap is initialized above.
-            
             if (shouldFetch) {
-                promises.push(
-                    this[loaderMethod](dString)
-                        .then(data => ({ date: dString, data }))
-                        .catch(err => {
-                            console.warn(`[CachedDataLoader] Failed to load series item ${loaderMethod} for ${dString}: ${err.message}`);
-                            return { date: dString, data: null };
-                        })
-                );
-            } else {
-                skippedCount++;
+                const ref = this.deps.db.collection(collectionName).doc(dString);
+                batchRefs.push(ref);
+                dateKeyMap.push(dString);
             }
         }
 
-        const loaded = await Promise.all(promises);
-        
+        // 5. Execute Batch Read
+        const results = {};
         let foundCount = 0;
-        loaded.forEach(({ date, data }) => {
-            if (data) {
-                results[date] = data;
-                foundCount++;
-            }
-        });
 
-        // Debug log to confirm efficiency
-        if (skippedCount > 0) {
-            // console.debug(`[CachedDataLoader] Smart Series Load: Requested ${lookbackDays}, Found ${foundCount}, Skipped ${skippedCount} missing dates.`);
+        if (batchRefs.length > 0) {
+            try {
+                const snapshots = await this.deps.db.getAll(...batchRefs);
+                
+                snapshots.forEach((snap, index) => {
+                    if (snap.exists) {
+                        const dString = dateKeyMap[index];
+                        const rawData = snap.data();
+                        
+                        // Decompress and clean data
+                        const decompressed = this._tryDecompress(rawData);
+                        
+                        // Handle standard data shapes (removing metadata fields if necessary)
+                        // Most root data loaders return the full object, so we do too.
+                        // Specific logic from data_loader.js (like stripping 'date' key) is handled here generically
+                        // or by the consumer. For series data, returning the whole object is usually safer.
+                        
+                        // Special handling for cleaner output (mimicking data_loader.js logic)
+                        if (loaderMethod === 'loadRatings' || loaderMethod === 'loadPageViews' || 
+                            loaderMethod === 'loadWatchlistMembership' || loaderMethod === 'loadAlertHistory') {
+                            const { date, lastUpdated, ...cleanData } = decompressed;
+                            results[dString] = cleanData;
+                        } else if (loaderMethod === 'loadRankings') {
+                            results[dString] = decompressed.Items || [];
+                        } else {
+                            results[dString] = decompressed;
+                        }
+                        
+                        foundCount++;
+                    }
+                });
+            } catch (err) {
+                console.warn(`[CachedDataLoader] Batch fetch failed for ${loaderMethod}: ${err.message}. Falling back to individual fetches.`);
+                return this._loadSeriesLegacy(loaderMethod, dateStr, lookbackDays);
+            }
         }
 
         return {
@@ -274,6 +286,39 @@ class CachedDataLoader {
             requested: lookbackDays
         };
     }
+
+    /**
+     * Legacy Fallback: Loads series using parallel promises (for custom/unmapped loaders)
+     */
+    async _loadSeriesLegacy(loaderMethod, dateStr, lookbackDays) {
+        const results = {};
+        const promises = [];
+        const endDate = new Date(dateStr);
+
+        for (let i = 0; i < lookbackDays; i++) {
+            const d = new Date(endDate);
+            d.setUTCDate(d.getUTCDate() - i);
+            const dString = d.toISOString().slice(0, 10);
+            
+            promises.push(
+                this[loaderMethod](dString)
+                    .then(data => ({ date: dString, data }))
+                    .catch(() => ({ date: dString, data: null }))
+            );
+        }
+
+        const loaded = await Promise.all(promises);
+        loaded.forEach(({ date, data }) => {
+            if (data) results[date] = data;
+        });
+
+        return {
+            dates: Object.keys(results).sort(),
+            data: results,
+            found: Object.keys(results).length,
+            requested: lookbackDays
+        };
+    }
 }
 
-module.exports = { CachedDataLoader };
+module.exports = { CachedDataLoader };

package/package.json

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