bulltrackers-module 1.0.768 → 1.0.770

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/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;

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

@@ -0,0 +1,227 @@
+/**
+ * @fileoverview PI Feature Vectors
+ * 
+ * Global computation that builds normalized feature vectors for all Popular Investors.
+ * Used by PiRecommender to find balanced recommendations.
+ * 
+ * Features computed per PI:
+ * - Sector exposure (normalized %)
+ * - Risk profile (volatility, risk score)
+ * - Performance metrics (gain %, win ratio)
+ * - Quality indicators (AUM tier, copiers)
+ */
+const { Computation } = require('../framework');
+
+class PiFeatureVectors extends Computation {
+    static getConfig() {
+        return {
+            name: 'PiFeatureVectors',
+            description: 'Computes feature vectors for all PIs for recommendation matching',
+            type: 'global',
+            category: 'popular_investor',
+            isHistorical: false,
+
+            requires: {
+                'portfolio_snapshots': {
+                    lookback: 0,
+                    mandatory: true,
+                    fields: ['user_id', 'portfolio_data', 'date'],
+                    filter: { user_type: 'POPULAR_INVESTOR' }
+                },
+                'pi_rankings': {
+                    lookback: 1,
+                    mandatory: true,
+                    fields: ['pi_id', 'rankings_data', 'username', 'date']
+                },
+                'pi_master_list': {
+                    lookback: 1,
+                    mandatory: false,
+                    fields: ['cid', 'username', 'verified_date']
+                },
+                'ticker_mappings': { mandatory: false },
+                'sector_mappings': { mandatory: false }
+            },
+
+            storage: {
+                bigquery: true,
+                firestore: { enabled: false }
+            }
+        };
+    }
+
+    async process(context) {
+        const { data, rules, targetDate } = context;
+
+        // ===========================================================================
+        // SETUP: Helpers and reference data
+        // ===========================================================================
+        const toArray = (input) => {
+            if (!input) return [];
+            if (Array.isArray(input)) return input;
+            // Handle Map-like structure from DataFetcher
+            return Object.values(input).flat();
+        };
+
+        // Build sector lookup
+        const tickerMap = new Map();
+        toArray(data['ticker_mappings']).forEach(row => {
+            if (row.instrument_id && row.ticker) {
+                tickerMap.set(Number(row.instrument_id), row.ticker.toUpperCase());
+            }
+        });
+
+        const sectorMap = new Map();
+        toArray(data['sector_mappings']).forEach(row => {
+            if (row.symbol && row.sector) {
+                sectorMap.set(row.symbol.toUpperCase(), row.sector);
+            }
+        });
+
+        const resolveSector = (instrumentId) => {
+            const ticker = tickerMap.get(Number(instrumentId));
+            return ticker ? (sectorMap.get(ticker) || 'Other') : 'Other';
+        };
+
+        // All known sectors for consistent vector dimensions
+        const ALL_SECTORS = [
+            'Technology', 'Healthcare', 'Financial Services', 'Consumer Cyclical',
+            'Industrials', 'Energy', 'Utilities', 'Real Estate', 'Communication Services',
+            'Consumer Defensive', 'Basic Materials', 'Crypto', 'Commodities', 'ETF', 'Other'
+        ];
+
+        // ===========================================================================
+        // GATHER: PI portfolio and rankings data
+        // ===========================================================================
+        const rankings = toArray(data['pi_rankings']);
+        const portfolios = data['portfolio_snapshots']; // Map { piId: [rows] }
+        const masterList = toArray(data['pi_master_list']);
+
+        // Build username lookup
+        const usernameMap = new Map();
+        rankings.forEach(r => {
+            const id = String(r.pi_id || r.CustomerId);
+            usernameMap.set(id, r.username || r.UserName);
+        });
+        masterList.forEach(m => {
+            if (m.cid && m.username) usernameMap.set(String(m.cid), m.username);
+        });
+
+        // ===========================================================================
+        // COMPUTE: Feature vectors for each PI
+        // ===========================================================================
+        const featureVectors = {};
+
+        // Process each PI's portfolio
+        const piIds = Object.keys(portfolios || {});
+
+        for (const piId of piIds) {
+            const rows = Array.isArray(portfolios[piId]) ? portfolios[piId] : [portfolios[piId]];
+            const latestRow = rows[rows.length - 1];
+            if (!latestRow) continue;
+
+            // Extract positions
+            const pData = rules.portfolio.extractPortfolioData(latestRow);
+            const positions = rules.portfolio.extractPositions(pData);
+
+            if (positions.length === 0) continue;
+
+            // Calculate sector exposure
+            const sectorWeights = {};
+            let totalValue = 0;
+
+            positions.forEach(pos => {
+                const instrumentId = rules.portfolio.getInstrumentId(pos);
+                const invested = rules.portfolio.getInvested(pos) || 0;
+                const sector = resolveSector(instrumentId);
+
+                sectorWeights[sector] = (sectorWeights[sector] || 0) + invested;
+                totalValue += invested;
+            });
+
+            // Normalize sector exposure to percentages
+            const sectorVector = {};
+            ALL_SECTORS.forEach(s => {
+                sectorVector[s] = totalValue > 0
+                    ? Number(((sectorWeights[s] || 0) / totalValue).toFixed(4))
+                    : 0;
+            });
+
+            // Get ranking data
+            if (piIds.indexOf(piId) === 0) {
+                const availableIds = rankings.map(r => r.pi_id || 'undefined').join(',');
+                console.log(`[DEBUG] Available IDs in rankings: ${availableIds}`);
+                console.log(`[DEBUG] First ranking row keys: ${Object.keys(rankings[0] || {}).join(',')}`);
+                if (rankings[0]) console.log(`[DEBUG] First ranking row pi_id: ${rankings[0].pi_id}`);
+            }
+            const rankRow = rankings.find(r => String(r.pi_id || r.CustomerId) === String(piId));
+
+            if (piIds.indexOf(piId) === 0) {
+                console.log(`[DEBUG] PiId: ${piId}`);
+                console.log(`[DEBUG] RankRow found: ${!!rankRow}`);
+                if (rankRow) {
+                    console.log(`[DEBUG] RankRow keys: ${Object.keys(rankRow).join(',')}`);
+                    console.log(`[DEBUG] RankingsData type: ${typeof rankRow.rankings_data}`);
+                    if (typeof rankRow.rankings_data === 'object') {
+                        console.log(`[DEBUG] RankingsData keys: ${Object.keys(rankRow.rankings_data).join(',')}`);
+                        console.log(`[DEBUG] RankingsData.Gain: ${rankRow.rankings_data.Gain}`);
+                    }
+                }
+            }
+
+            let riskScore = 5, gain = 0, copiers = 0, winRatio = 0, aumTier = 0;
+
+            if (rankRow) {
+                const rData = rules.rankings.extractRankingsData(rankRow);
+                if (rData) {
+                    riskScore = rules.rankings.getRiskScore(rData) || 5;
+                    gain = rules.rankings.getTotalGain(rData) || 0;
+                    copiers = rules.rankings.getCopiers(rData) || 0;
+                    winRatio = rules.rankings.getWinRatio(rData) || 0;
+                    aumTier = rules.rankings.getAUMTier(rData) || 0;
+                }
+            }
+
+            // Calculate concentration (Herfindahl index) - higher = more concentrated
+            const weights = Object.values(sectorWeights).filter(w => w > 0);
+            const hhi = totalValue > 0
+                ? weights.reduce((sum, w) => sum + Math.pow(w / totalValue, 2), 0)
+                : 1;
+
+            // Assemble feature vector
+            featureVectors[piId] = {
+                piId: String(piId),
+                username: usernameMap.get(String(piId)) || 'Unknown',
+
+                // Sector exposure (normalized)
+                sectors: sectorVector,
+
+                // Risk profile
+                riskScore: riskScore,
+                concentration: Number(hhi.toFixed(4)),  // 0-1, higher = less diversified
+
+                // Performance
+                gain: gain,
+                winRatio: winRatio,
+
+                // Quality
+                copiers: copiers,
+                aumTier: aumTier,
+                positionCount: positions.length,
+
+                // Metadata
+                totalValue: Number(totalValue.toFixed(2)),
+                computedAt: targetDate
+            };
+        }
+
+        // Store all vectors as a single global result
+        this.setResult('_global', {
+            vectors: featureVectors,
+            piCount: Object.keys(featureVectors).length,
+            sectorDimensions: ALL_SECTORS,
+            computedAt: targetDate
+        });
+    }
+}
+
+module.exports = PiFeatureVectors;