bulltrackers-module 1.0.766 → 1.0.769

package/functions/computation-system-v2/computations/GlobalAumPerAsset30D.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Aggregates $ AUM per asset across ALL Popular Investors.
+ * * STRATEGY: Global Computation (Reduce Step).
+ * * INPUT: Reads 'computation_results' for 'pidailyassetaum'.
+ * * OUTPUT: List of { symbol, amount } for Materialized View generation.
+ */
+const { Computation } = require('../framework');
+
+class GlobalAumPerAsset extends Computation {
+
+    static getConfig() {
+        return {
+            name: 'GlobalAumPerAsset',
+            type: 'global',
+            category: 'market_insights',
+            
+            requires: {
+                'computation_results': {
+                    lookback: 0, 
+                    mandatory: true,
+                    fields: ['result_data', 'computation_name', 'date'],
+                    // Lowercase to match BigQuery storage
+                    filter: { 
+                        computation_name: 'pidailyassetaum' 
+                    }
+                }
+            },
+            
+            dependencies: ['PIDailyAssetAUM'],
+
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: true,
+                    path: 'global_metrics/aum_per_asset_{date}',
+                    merge: true
+                }
+            }
+        };
+    }
+
+    async process(context) {
+        const { data } = context;
+
+        let rows = data['computation_results'];
+        if (!rows) {
+             console.log('[GlobalAumPerAsset] No input data found.');
+             return;
+        }
+
+        if (!Array.isArray(rows) && typeof rows === 'object') {
+            rows = Object.values(rows);
+        }
+
+        if (rows.length === 0) {
+            console.log('[GlobalAumPerAsset] Input array is empty.');
+            return;
+        }
+
+        console.log(`[GlobalAumPerAsset] Aggregating ${rows.length} PI portfolios...`);
+
+        const globalTotals = new Map();
+        let piCount = 0;
+
+        for (const row of rows) {
+            let assetMap = row.result_data;
+            
+            if (typeof assetMap === 'string') {
+                try { assetMap = JSON.parse(assetMap); } catch (e) { continue; }
+            }
+            
+            if (!assetMap) continue;
+
+            piCount++;
+            
+            for (const [ticker, value] of Object.entries(assetMap)) {
+                if (typeof value === 'number') {
+                    const current = globalTotals.get(ticker) || 0;
+                    globalTotals.set(ticker, current + value);
+                }
+            }
+        }
+
+        const materializedViewData = [];
+        for (const [symbol, amount] of globalTotals.entries()) {
+            if (amount > 0) {
+                materializedViewData.push({
+                    symbol: symbol,
+                    amount: Number(amount.toFixed(2))
+                });
+            }
+        }
+
+        materializedViewData.sort((a, b) => b.amount - a.amount);
+
+        console.log(`[GlobalAumPerAsset] Generated stats for ${materializedViewData.length} unique assets from ${piCount} PIs.`);
+
+        // FIX: Use '_global' to match Orchestrator context (was 'global')
+        this.setResult('_global', materializedViewData);
+    }
+}
+
+module.exports = GlobalAumPerAsset;

package/functions/computation-system-v2/computations/NewSectorExposure.js

@@ -1,17 +1,15 @@
+/**
+ * @fileoverview New Sector Exposure Alert
+ * Refactored to map InstrumentID -> Ticker -> Sector (Industry)
+ * UPDATE: Uses "Last Known" logic for previous state (Lookback 14 days)
+ * Confirmed working 29/01/2026
+ */
 const { Computation } = require('../framework');
 
 class NewSectorExposure extends Computation {
     
     constructor() {
         super();
-        this.SECTOR_MAPPING = {
-            1: 'Currencies',
-            2: 'Commodities',
-            4: 'Indices',
-            5: 'Stocks',
-            6: 'ETF',
-            10: 'Cryptocurrencies'
-        };
     }
 
     static getConfig() {
@@ -23,9 +21,15 @@ class NewSectorExposure extends Computation {
             
             requires: {
                 'portfolio_snapshots': {
-                    lookback: 1, // Today + Yesterday
+                    lookback: 14, // INCREASED: Look back 2 weeks to find last known state
                     mandatory: true,
                     fields: ['user_id', 'portfolio_data', 'date']
+                },
+                'ticker_mappings': {
+                    mandatory: false
+                },
+                'sector_mappings': {
+                    mandatory: false
                 }
             },
 
@@ -38,12 +42,11 @@ class NewSectorExposure extends Computation {
                 }
             },
 
-            // LEGACY METADATA
             userType: 'POPULAR_INVESTOR',
             alert: {
                 id: 'newSector',
                 frontendName: 'New Sector Entry',
-                description: 'Alert when a Popular Investor enters a new sector category',
+                description: 'Alert when a Popular Investor enters a new industry sector',
                 messageTemplate: '{piUsername} entered new sector(s): {sectorName}',
                 severity: 'low',
                 configKey: 'newSector',
@@ -55,7 +58,7 @@ class NewSectorExposure extends Computation {
                             type: 'multiselect',
                             label: 'Watch specific sectors',
                             description: 'Only alert for these sectors',
-                            options: ['Stocks', 'Cryptocurrencies', 'ETF', 'Indices', 'Commodities', 'Currencies'],
+                            options: ['Technology', 'Basic Materials', 'Consumer Cyclical', 'Financial Services', 'Real Estate', 'Healthcare', 'Energy', 'Industrials'],
                             default: []
                         }
                     ],
@@ -70,49 +73,90 @@ class NewSectorExposure extends Computation {
     async process(context) {
         const { data, entityId, date, rules } = context;
 
-        // 1. Get Data
+        // 1. Get Data Sources
         const history = data['portfolio_snapshots'] || [];
-        const todayRow = history.find(d => d.date === date);
+        // FIX: Handle DataFetcher returning Objects (keyed by ID) or Arrays.
+        const tickerRows = Object.values(data['ticker_mappings'] || {});
+        const sectorRows = Object.values(data['sector_mappings'] || {});
+
+        // 2. Build Mapping Dictionaries
+        const tickerMap = new Map();
+        tickerRows.forEach(row => {
+            if (row.instrument_id && row.ticker) {
+                tickerMap.set(Number(row.instrument_id), row.ticker.toUpperCase());
+            }
+        });
+
+        const sectorMap = new Map();
+        sectorRows.forEach(row => {
+            if (row.symbol && row.sector && row.sector !== 'N/A') {
+                sectorMap.set(row.symbol.toUpperCase(), row.sector);
+            }
+        });
+
+        const resolveSector = (instrumentId) => {
+            const ticker = tickerMap.get(Number(instrumentId));
+            if (!ticker) return null;
+            return sectorMap.get(ticker);
+        };
+
+        // 3. Helper to handle BigQuery Dates
+        const toDateStr = (d) => {
+            if (!d) return null;
+            if (d.value) return d.value;
+            return d;
+        };
+
+        // 4. Find Today and Last Known Previous Row
+        // Sort history descending by date to find the most recent previous entry
+        history.sort((a, b) => {
+            const dateA = toDateStr(a.date);
+            const dateB = toDateStr(b.date);
+            return dateB.localeCompare(dateA); // Descending (Newest First)
+        });
+
+        const todayRow = history.find(d => toDateStr(d.date) === date);
         
-        // Calc yesterday date
-        const yDate = new Date(date);
-        yDate.setDate(yDate.getDate() - 1);
-        const yDateStr = yDate.toISOString().split('T')[0];
-        const yesterdayRow = history.find(d => d.date === yDateStr);
+        // Find the first row where date is strictly less than target date
+        // Since we sorted descending, this is the "Last Known" date
+        const previousRow = history.find(d => toDateStr(d.date) < date);
 
-        // 2. Extract Data
+        // 5. Extract Portfolio Data
         const todayData = rules.portfolio.extractPortfolioData(todayRow);
-        const yesterdayData = rules.portfolio.extractPortfolioData(yesterdayRow);
+        const previousData = rules.portfolio.extractPortfolioData(previousRow);
 
         if (!todayData) return;
 
-        // 3. Helper to get Sector Map
+        // 6. Calculate Sector Exposures
         const getSectorMap = (pData) => {
             const map = new Map();
-            // Using Rule: extractPositionsByType gives AggregatedPositionsByInstrumentTypeID
-            const aggs = rules.portfolio.extractPositionsByType(pData);
+            const positions = rules.portfolio.extractPositions(pData);
             
-            aggs.forEach(agg => {
-                const typeId = agg.InstrumentTypeID;
-                const invested = agg.Invested || 0;
+            positions.forEach(pos => {
+                const instrumentId = rules.portfolio.getInstrumentId(pos);
+                const invested = rules.portfolio.getInvested(pos); 
                 
-                if (typeId && invested > 0) {
-                    const sectorName = this.SECTOR_MAPPING[typeId];
-                    if (sectorName) map.set(sectorName, invested);
+                if (instrumentId && invested > 0) {
+                    const sectorName = resolveSector(instrumentId);
+                    if (sectorName) {
+                        const current = map.get(sectorName) || 0;
+                        map.set(sectorName, current + invested);
+                    }
                 }
             });
             return map;
         };
 
         const todaySectors = getSectorMap(todayData);
-        const yesterdaySectors = getSectorMap(yesterdayData);
+        const previousSectors = getSectorMap(previousData);
 
+        // 7. Compare
         const newExposures = [];
-        const isBaselineReset = (!yesterdayData);
+        const isBaselineReset = (!previousData); // True if no previous history found
 
         if (!isBaselineReset) {
             for (const [sectorName, invested] of todaySectors) {
-                const prevInvested = yesterdaySectors.get(sectorName) || 0;
+                const prevInvested = previousSectors.get(sectorName) || 0;
                 if (prevInvested === 0 && invested > 0) {
                     newExposures.push(sectorName);
                 }
@@ -121,11 +165,14 @@ class NewSectorExposure extends Computation {
 
         const result = {
             currentSectors: Array.from(todaySectors.keys()),
-            previousSectors: isBaselineReset ? [] : Array.from(yesterdaySectors.keys()),
+            previousSectors: isBaselineReset ? [] : Array.from(previousSectors.keys()),
             newExposures,
             sectorName: newExposures.join(', '), 
             isBaselineReset,
-            triggered: newExposures.length > 0
+            triggered: newExposures.length > 0,
+            _metadata: {
+                previousDate: previousRow ? toDateStr(previousRow.date) : null
+            }
         };
 
         this.setResult(entityId, result);

package/functions/computation-system-v2/computations/NewSocialPost.js

@@ -1,3 +1,8 @@
+/**
+ * @fileoverview New Social Post Alert
+ * Logic: Alerts ONLY if a post exists with a creation date matching the current run date.
+ * Relies on DataFetcher V2.8+ to handle JSON parsing/double-encoding.
+ */
 const { Computation } = require('../framework');
 
 class NewSocialPost extends Computation {
@@ -7,11 +12,11 @@ class NewSocialPost extends Computation {
             name: 'NewSocialPost',
             type: 'per-entity',
             category: 'alerts',
-            isHistorical: false,
+            isHistorical: true,
             
             requires: {
                 'social_post_snapshots': {
-                    lookback: 0,
+                    lookback: 5, // Short lookback just to ensure we catch the specific row
                     mandatory: true,
                     fields: ['user_id', 'posts_data', 'date']
                 }
@@ -26,19 +31,15 @@ class NewSocialPost extends Computation {
                 }
             },
 
-            // LEGACY METADATA
             userType: 'POPULAR_INVESTOR',
             alert: {
                 id: 'newSocialPost',
                 frontendName: 'New Social Post',
-                description: 'Alert when a Popular Investor makes a new social post',
+                description: 'Alert when a Popular Investor makes a new social post today',
                 messageTemplate: '{piUsername} posted a new update: {title}',
                 severity: 'low',
                 configKey: 'newSocialPost',
-                isDynamic: false,
-                thresholds: [],
-                conditions: [],
-                resultKeys: ['hasNewPost', 'latestPostDate', 'postCount', 'title']
+                isDynamic: false
             }
         };
     }
@@ -46,50 +47,77 @@ class NewSocialPost extends Computation {
     async process(context) {
         const { data, entityId, date, rules } = context;
 
-        // 1. Get Data using Rules
-        // V2 data structure: data['table'][entityId] is the row (when lookback=0)
-        const row = data['social_post_snapshots']; 
-        const posts = rules.social.extractPosts(row);
+        // 1. Get History
+        const history = data['social_post_snapshots'] || [];
+        
+        // Helper: Handle BigQuery Date Objects
+        const toDateStr = (d) => {
+            if (!d) return null;
+            if (d.value) return d.value;
+            return d;
+        };
+
+        // 2. Find the Snapshot for "Today" (The Execution Date)
+        // We strictly want to know if they posted *on this specific date*.
+        const todayRow = history.find(d => toDateStr(d.date) === date);
+
+        if (!todayRow) {
+            // No snapshot exists for this date yet, so we can't determine if they posted.
+            this.setResult(entityId, { 
+                hasNewPost: false, 
+                triggered: false,
+                reason: "No snapshot found for date" 
+            });
+            return;
+        }
+
+        // 3. Extract Posts
+        // (DataFetcher V2.8 automatically handles the double-encoded JSON)
+        const posts = rules.social.extractPosts(todayRow);
 
         let hasNewPost = false;
         let latestPost = null;
 
-        // 2. Logic
+        // 4. Check for posts created "Today"
         for (const post of posts) {
-            const postDate = rules.social.getPostDate(post);
-            if (!postDate) continue;
+            const postDateObj = rules.social.getPostDate(post);
+            if (!postDateObj) continue;
+
+            // Format YYYY-MM-DD
+            const postDateStr = postDateObj.toISOString().slice(0, 10);
 
-            // Check matches today (YYYY-MM-DD)
-            if (postDate.toISOString().slice(0, 10) === date) {
+            if (postDateStr === date) {
                 hasNewPost = true;
                 
-                const latestDate = latestPost ? rules.social.getPostDate(latestPost) : new Date(0);
-                if (postDate > latestDate) {
+                // Track the latest one for the alert title
+                if (!latestPost || postDateObj > rules.social.getPostDate(latestPost)) {
                     latestPost = post;
                 }
             }
         }
 
-        // 3. Title Extraction
+        // 5. Format Title for Alert
         let displayTitle = 'New Update';
         if (latestPost) {
             const text = rules.social.getPostText(latestPost);
-            const rawTitle = latestPost.Title; // Fallback if rule doesn't cover Title specifically
+            const rawTitle = latestPost.Title;
 
             if (rawTitle) {
                 displayTitle = rawTitle;
             } else if (text) {
-                displayTitle = text.substring(0, 50).replace(/\n/g, ' ');
-                if (text.length > 50) displayTitle += '...';
+                // Truncate text for display
+                displayTitle = text.substring(0, 60).replace(/\n/g, ' ');
+                if (text.length > 60) displayTitle += '...';
             }
         }
 
+        // 6. Set Result
         const result = {
             hasNewPost,
             latestPostDate: latestPost ? rules.social.getPostDate(latestPost) : null,
             postCount: posts.length,
             title: displayTitle,
-            triggered: hasNewPost
+            triggered: hasNewPost // Only triggers if a post matched today's date
         };
 
         this.setResult(entityId, result);

package/functions/computation-system-v2/computations/PIDailyAssetAUM.js

@@ -0,0 +1,134 @@
+const { Computation } = require('../framework');
+
+class PIDailyAssetAUM extends Computation {
+
+    static getConfig() {
+        return {
+            name: 'PIDailyAssetAUM',
+            type: 'per-entity',
+            category: 'popular_investor',
+            isHistorical: true,
+            
+            requires: {
+                // Driver: Only process Popular Investors
+                'portfolio_snapshots': {
+                    lookback: 30, // Extended lookback to ensure we find snapshots
+                    mandatory: true,
+                    fields: ['user_id', 'portfolio_data', 'date', 'user_type'],
+                    filter: { user_type: 'POPULAR_INVESTOR' }
+                },
+                'pi_rankings': {
+                    lookback: 30, // Extended lookback to match portfolios
+                    mandatory: true,
+                    fields: ['pi_id', 'rankings_data', 'date']
+                },
+                'ticker_mappings': { 
+                    mandatory: false,
+                    fields: ['instrument_id', 'ticker'] 
+                }, 
+                'pi_master_list': { 
+                    mandatory: false,
+                    fields: ['cid', 'username'] 
+                }
+            },
+
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: true,
+                    path: 'popular_investors/{entityId}/metrics/asset_aum_{date}',
+                    merge: true
+                }
+            }
+        };
+    }
+
+    async process(context) {
+        const { data, entityId, rules } = context;
+
+        // --- HELPER: Safe Date Parser ---
+        // Handles BigQuery { value: '2023-01-01' } objects to prevent NaN errors
+        const parseDate = (d) => {
+            if (!d) return null;
+            if (d instanceof Date) return d;
+            if (typeof d === 'object' && d.value) return new Date(d.value);
+            return new Date(d);
+        };
+
+        const getEntityRows = (dataset) => {
+            if (!dataset) return [];
+            if (dataset[entityId]) return Array.isArray(dataset[entityId]) ? dataset[entityId] : [dataset[entityId]];
+            // Handle mismatched ID columns (user_id vs pi_id)
+            if (Array.isArray(dataset)) return dataset.filter(r => String(r.user_id || r.pi_id || r.cid) === String(entityId));
+            return [];
+        };
+        
+        // Mappings
+        const tickerMap = new Map();
+        const mappingsList = Array.isArray(context.data['ticker_mappings']) ? context.data['ticker_mappings'] : Object.values(context.data['ticker_mappings'] || {});
+        mappingsList.forEach(row => { if (row.instrument_id) tickerMap.set(Number(row.instrument_id), row.ticker); });
+        const resolveTicker = (id) => tickerMap.get(Number(id)) || `ID:${id}`;
+
+        // 2. Get Valid Snapshots
+        const portfolios = getEntityRows(data['portfolio_snapshots']);
+        const rankings = getEntityRows(data['pi_rankings']);
+
+        let validPortfolio = null;
+        let validRanking = null;
+
+        // Sort descending using safe date parsing
+        portfolios.sort((a,b) => parseDate(b.date) - parseDate(a.date));
+        rankings.sort((a,b) => parseDate(b.date) - parseDate(a.date));
+
+        if (portfolios.length > 0) {
+            validPortfolio = portfolios[0];
+            const pDate = parseDate(validPortfolio.date);
+
+            validRanking = rankings.find(r => {
+                const rDate = parseDate(r.date);
+                const diffTime = Math.abs(pDate - rDate);
+                const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+                
+                // Allow up to 14 days gap (matches your data reality)
+                return diffDays <= 14;
+            });
+        }
+
+        if (!validPortfolio || !validRanking) {
+            return;
+        }
+
+        // 3. Calculation
+        const pData = rules.portfolio.extractPortfolioData(validPortfolio);
+        const rData = rules.rankings.extractRankingsData(validRanking);
+        
+        // FIX: Use 'getAUM' (checked from rules/rankings.js)
+        const totalAum = rules.rankings.getAUM(rData); 
+        
+        if (!totalAum || totalAum <= 0) return;
+
+        const positions = rules.portfolio.extractPositions(pData);
+        const assetAumMap = {};
+
+        positions.forEach(pos => {
+            const id = rules.portfolio.getInstrumentId(pos);
+            const ticker = resolveTicker(id);
+            
+            // FIX: Use 'getInvested' (checked from rules/portfolio.js)
+            const weight = rules.portfolio.getInvested(pos); 
+            
+            if (weight > 0) {
+                // weight is a percentage (e.g., 5.5 for 5.5%), so divide by 100
+                const dollarValue = (weight / 100) * totalAum;
+                assetAumMap[ticker] = (assetAumMap[ticker] || 0) + dollarValue;
+            }
+        });
+
+        // 4. Formatting
+        Object.keys(assetAumMap).forEach(k => assetAumMap[k] = Number(assetAumMap[k].toFixed(2)));
+
+        this.setResult(entityId, assetAumMap);
+    }
+}
+
+module.exports = PIDailyAssetAUM;