bulltrackers-module 1.0.733 → 1.0.734

package/functions/computation-system-v2/rules/trades.js

@@ -0,0 +1,545 @@
+/**
+ * @fileoverview Trade History Business Rules
+ * 
+ * For extracting and analyzing trade_history_snapshots data.
+ * Each row contains PublicHistoryPositions - an array of closed trades.
+ * 
+ * NOTE: Trade history shows individual closed positions. We can see:
+ * - Net profit percentage per trade
+ * - Open/close rates and dates
+ * - Leverage and direction
+ * 
+ * We CANNOT determine the invested amount per position from this data alone.
+ * 
+ * Usage in computation:
+ * ```javascript
+ * const trades = rules.trades.extractTrades(row);
+ * const stats = rules.trades.calculateTradeStats(trades);
+ * const byInstrument = rules.trades.groupByInstrument(trades);
+ * ```
+ */
+
+// =============================================================================
+// DATA EXTRACTION
+// =============================================================================
+
+/**
+ * Extract trades array from a trade_history_snapshots row.
+ * @param {Object} row - trade_history_snapshots row
+ * @returns {Array} Array of trade objects
+ */
+function extractTrades(row) {
+    if (!row) return [];
+    
+    let data = row.history_data;
+    
+    if (typeof data === 'string') {
+        try {
+            data = JSON.parse(data);
+        } catch (e) {
+            return [];
+        }
+    }
+    
+    return data?.PublicHistoryPositions || [];
+}
+
+/**
+ * Get user ID from trade history row.
+ * @param {Object} row - trade_history_snapshots row
+ * @returns {string|null}
+ */
+function getUserId(row) {
+    if (!row) return null;
+    
+    // Try row-level first
+    if (row.user_id) return String(row.user_id);
+    
+    // Try from history_data
+    let data = row.history_data;
+    if (typeof data === 'string') {
+        try {
+            data = JSON.parse(data);
+        } catch (e) {
+            return null;
+        }
+    }
+    
+    return data?.cid ? String(data.cid) : null;
+}
+
+// =============================================================================
+// TRADE PROPERTY ACCESSORS
+// =============================================================================
+
+/**
+ * Get instrument ID from a trade.
+ * @param {Object} trade - Trade object
+ * @returns {number|null}
+ */
+function getInstrumentId(trade) {
+    return trade?.InstrumentID || null;
+}
+
+/**
+ * Get net profit percentage.
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getNetProfit(trade) {
+    return trade?.NetProfit ?? 0;
+}
+
+/**
+ * Get open rate (price at open).
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getOpenRate(trade) {
+    return trade?.OpenRate ?? 0;
+}
+
+/**
+ * Get close rate (price at close).
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getCloseRate(trade) {
+    return trade?.CloseRate ?? 0;
+}
+
+/**
+ * Get open date.
+ * @param {Object} trade - Trade object
+ * @returns {Date|null}
+ */
+function getOpenDate(trade) {
+    return trade?.OpenDateTime ? new Date(trade.OpenDateTime) : null;
+}
+
+/**
+ * Get close date.
+ * @param {Object} trade - Trade object
+ * @returns {Date|null}
+ */
+function getCloseDate(trade) {
+    return trade?.CloseDateTime ? new Date(trade.CloseDateTime) : null;
+}
+
+/**
+ * Get leverage (integer).
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getLeverage(trade) {
+    return trade?.Leverage ?? 1;
+}
+
+/**
+ * Check if trade was a buy (long).
+ * @param {Object} trade - Trade object
+ * @returns {boolean}
+ */
+function isBuy(trade) {
+    return trade?.IsBuy === true;
+}
+
+/**
+ * Check if trade was a sell (short).
+ * @param {Object} trade - Trade object
+ * @returns {boolean}
+ */
+function isSell(trade) {
+    return trade?.IsBuy === false;
+}
+
+/**
+ * Get position ID.
+ * @param {Object} trade - Trade object
+ * @returns {number|null}
+ */
+function getPositionId(trade) {
+    return trade?.PositionID || null;
+}
+
+/**
+ * Get close reason code.
+ * Close reasons: 0 = manual, 5 = stop loss, etc.
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getCloseReason(trade) {
+    return trade?.CloseReason ?? 0;
+}
+
+/**
+ * Check if trade was profitable.
+ * @param {Object} trade - Trade object
+ * @returns {boolean}
+ */
+function isProfitable(trade) {
+    return getNetProfit(trade) > 0;
+}
+
+/**
+ * Calculate trade duration in days.
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getDurationDays(trade) {
+    const open = getOpenDate(trade);
+    const close = getCloseDate(trade);
+    
+    if (!open || !close) return 0;
+    
+    return (close - open) / (1000 * 60 * 60 * 24);
+}
+
+/**
+ * Calculate price change percentage.
+ * @param {Object} trade - Trade object
+ * @returns {number}
+ */
+function getPriceChangePct(trade) {
+    const open = getOpenRate(trade);
+    const close = getCloseRate(trade);
+    
+    if (!open || open === 0) return 0;
+    
+    return ((close - open) / open) * 100;
+}
+
+// =============================================================================
+// FILTERING
+// =============================================================================
+
+/**
+ * Filter trades by date range.
+ * @param {Array} trades - Array of trades
+ * @param {Date|string} startDate - Start date
+ * @param {Date|string} endDate - End date
+ * @returns {Array}
+ */
+function filterByDateRange(trades, startDate, endDate) {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    
+    return trades.filter(trade => {
+        const closeDate = getCloseDate(trade);
+        return closeDate && closeDate >= start && closeDate <= end;
+    });
+}
+
+/**
+ * Filter trades by instrument.
+ * @param {Array} trades - Array of trades
+ * @param {number} instrumentId - Instrument ID
+ * @returns {Array}
+ */
+function filterByInstrument(trades, instrumentId) {
+    return trades.filter(trade => getInstrumentId(trade) === instrumentId);
+}
+
+/**
+ * Filter to only profitable trades.
+ * @param {Array} trades - Array of trades
+ * @returns {Array}
+ */
+function filterProfitable(trades) {
+    return trades.filter(isProfitable);
+}
+
+/**
+ * Filter to only losing trades.
+ * @param {Array} trades - Array of trades
+ * @returns {Array}
+ */
+function filterLosing(trades) {
+    return trades.filter(trade => !isProfitable(trade));
+}
+
+/**
+ * Filter to only long trades.
+ * @param {Array} trades - Array of trades
+ * @returns {Array}
+ */
+function filterLong(trades) {
+    return trades.filter(isBuy);
+}
+
+/**
+ * Filter to only short trades.
+ * @param {Array} trades - Array of trades
+ * @returns {Array}
+ */
+function filterShort(trades) {
+    return trades.filter(isSell);
+}
+
+/**
+ * Filter by leverage.
+ * @param {Array} trades - Array of trades
+ * @param {number} minLeverage - Minimum leverage
+ * @param {number} [maxLeverage] - Maximum leverage
+ * @returns {Array}
+ */
+function filterByLeverage(trades, minLeverage, maxLeverage = Infinity) {
+    return trades.filter(trade => {
+        const lev = getLeverage(trade);
+        return lev >= minLeverage && lev <= maxLeverage;
+    });
+}
+
+// =============================================================================
+// GROUPING
+// =============================================================================
+
+/**
+ * Group trades by instrument.
+ * @param {Array} trades - Array of trades
+ * @returns {Object} Map of instrumentId -> trades[]
+ */
+function groupByInstrument(trades) {
+    const groups = {};
+    
+    for (const trade of trades) {
+        const id = getInstrumentId(trade) || 'unknown';
+        if (!groups[id]) groups[id] = [];
+        groups[id].push(trade);
+    }
+    
+    return groups;
+}
+
+/**
+ * Group trades by month (YYYY-MM).
+ * @param {Array} trades - Array of trades
+ * @returns {Object} Map of month -> trades[]
+ */
+function groupByMonth(trades) {
+    const groups = {};
+    
+    for (const trade of trades) {
+        const closeDate = getCloseDate(trade);
+        if (!closeDate) continue;
+        
+        const month = `${closeDate.getFullYear()}-${String(closeDate.getMonth() + 1).padStart(2, '0')}`;
+        if (!groups[month]) groups[month] = [];
+        groups[month].push(trade);
+    }
+    
+    return groups;
+}
+
+/**
+ * Group trades by close reason.
+ * @param {Array} trades - Array of trades
+ * @returns {Object} Map of closeReason -> trades[]
+ */
+function groupByCloseReason(trades) {
+    const groups = {};
+    
+    for (const trade of trades) {
+        const reason = getCloseReason(trade);
+        if (!groups[reason]) groups[reason] = [];
+        groups[reason].push(trade);
+    }
+    
+    return groups;
+}
+
+// =============================================================================
+// STATISTICS
+// =============================================================================
+
+/**
+ * Calculate comprehensive trade statistics.
+ * @param {Array} trades - Array of trades
+ * @returns {Object}
+ */
+function calculateTradeStats(trades) {
+    if (!trades || trades.length === 0) {
+        return {
+            totalTrades: 0,
+            profitableTrades: 0,
+            losingTrades: 0,
+            winRate: 0,
+            avgProfit: 0,
+            avgWin: 0,
+            avgLoss: 0,
+            maxWin: 0,
+            maxLoss: 0,
+            profitFactor: 0,
+            avgDuration: 0,
+            longTrades: 0,
+            shortTrades: 0
+        };
+    }
+    
+    const profitable = filterProfitable(trades);
+    const losing = filterLosing(trades);
+    const long = filterLong(trades);
+    const short = filterShort(trades);
+    
+    const profits = trades.map(getNetProfit);
+    const wins = profitable.map(getNetProfit);
+    const losses = losing.map(getNetProfit);
+    const durations = trades.map(getDurationDays).filter(d => d > 0);
+    
+    const totalProfit = profits.reduce((sum, p) => sum + p, 0);
+    const totalWins = wins.reduce((sum, p) => sum + p, 0);
+    const totalLosses = Math.abs(losses.reduce((sum, p) => sum + p, 0));
+    
+    return {
+        totalTrades: trades.length,
+        profitableTrades: profitable.length,
+        losingTrades: losing.length,
+        winRate: trades.length > 0 ? (profitable.length / trades.length) * 100 : 0,
+        
+        avgProfit: trades.length > 0 ? totalProfit / trades.length : 0,
+        avgWin: wins.length > 0 ? totalWins / wins.length : 0,
+        avgLoss: losses.length > 0 ? totalLosses / losses.length : 0,
+        
+        maxWin: wins.length > 0 ? Math.max(...wins) : 0,
+        maxLoss: losses.length > 0 ? Math.min(...losses) : 0,
+        
+        profitFactor: totalLosses > 0 ? totalWins / totalLosses : totalWins > 0 ? Infinity : 0,
+        
+        avgDuration: durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0,
+        
+        longTrades: long.length,
+        shortTrades: short.length
+    };
+}
+
+/**
+ * Calculate statistics per instrument.
+ * @param {Array} trades - Array of trades
+ * @returns {Object} Map of instrumentId -> stats
+ */
+function calculateStatsByInstrument(trades) {
+    const groups = groupByInstrument(trades);
+    const stats = {};
+    
+    for (const [instrumentId, instrumentTrades] of Object.entries(groups)) {
+        stats[instrumentId] = {
+            ...calculateTradeStats(instrumentTrades),
+            instrumentId
+        };
+    }
+    
+    return stats;
+}
+
+/**
+ * Get recent trades.
+ * @param {Array} trades - Array of trades
+ * @param {number} count - Number of trades to return
+ * @returns {Array}
+ */
+function getRecentTrades(trades, count = 10) {
+    return [...trades]
+        .sort((a, b) => {
+            const dateA = getCloseDate(a);
+            const dateB = getCloseDate(b);
+            return (dateB || 0) - (dateA || 0);
+        })
+        .slice(0, count);
+}
+
+/**
+ * Get best trades by profit.
+ * @param {Array} trades - Array of trades
+ * @param {number} count - Number of trades to return
+ * @returns {Array}
+ */
+function getBestTrades(trades, count = 10) {
+    return [...trades]
+        .sort((a, b) => getNetProfit(b) - getNetProfit(a))
+        .slice(0, count);
+}
+
+/**
+ * Get worst trades by profit.
+ * @param {Array} trades - Array of trades
+ * @param {number} count - Number of trades to return
+ * @returns {Array}
+ */
+function getWorstTrades(trades, count = 10) {
+    return [...trades]
+        .sort((a, b) => getNetProfit(a) - getNetProfit(b))
+        .slice(0, count);
+}
+
+/**
+ * Summarize trade activity.
+ * @param {Object} row - trade_history_snapshots row
+ * @returns {Object}
+ */
+function summarize(row) {
+    const trades = extractTrades(row);
+    const stats = calculateTradeStats(trades);
+    const byInstrument = calculateStatsByInstrument(trades);
+    
+    // Find most traded instrument
+    let mostTraded = null;
+    let mostTradedCount = 0;
+    for (const [id, s] of Object.entries(byInstrument)) {
+        if (s.totalTrades > mostTradedCount) {
+            mostTraded = id;
+            mostTradedCount = s.totalTrades;
+        }
+    }
+    
+    return {
+        userId: getUserId(row),
+        ...stats,
+        uniqueInstruments: Object.keys(byInstrument).length,
+        mostTradedInstrument: mostTraded,
+        mostTradedCount
+    };
+}
+
+module.exports = {
+    // Data extraction
+    extractTrades,
+    getUserId,
+    
+    // Trade accessors
+    getInstrumentId,
+    getNetProfit,
+    getOpenRate,
+    getCloseRate,
+    getOpenDate,
+    getCloseDate,
+    getLeverage,
+    isBuy,
+    isSell,
+    getPositionId,
+    getCloseReason,
+    isProfitable,
+    getDurationDays,
+    getPriceChangePct,
+    
+    // Filtering
+    filterByDateRange,
+    filterByInstrument,
+    filterProfitable,
+    filterLosing,
+    filterLong,
+    filterShort,
+    filterByLeverage,
+    
+    // Grouping
+    groupByInstrument,
+    groupByMonth,
+    groupByCloseReason,
+    
+    // Statistics
+    calculateTradeStats,
+    calculateStatsByInstrument,
+    getRecentTrades,
+    getBestTrades,
+    getWorstTrades,
+    summarize
+};

package/functions/computation-system-v2/scripts/migrate-sectors.js

@@ -0,0 +1,73 @@
+const admin = require('firebase-admin');
+const { BigQuery } = require('@google-cloud/bigquery');
+
+// Configuration
+const PROJECT_ID = process.env.GCP_PROJECT_ID || 'stocks-12345';
+const DATASET_ID = 'bulltrackers_data'; // Check your config
+const TABLE_ID = 'sector_mappings';
+const FIRESTORE_PATH = 'instrument_sector_mappings/sector_mappings';
+
+async function migrate() {
+    console.log('🚀 Starting Sector Migration...');
+
+    // 1. Initialize Firestore
+    // Note: Assuming Application Default Credentials work. 
+    // If running locally, ensure you've done: gcloud auth application-default login
+    admin.initializeApp({ projectId: PROJECT_ID });
+    const db = admin.firestore();
+
+    // 2. Fetch Firestore Data
+    console.log(`Reading Firestore doc: ${FIRESTORE_PATH}...`);
+    const docRef = db.doc(FIRESTORE_PATH);
+    const doc = await docRef.get();
+
+    if (!doc.exists) {
+        throw new Error('Firestore document not found!');
+    }
+
+    const data = doc.data();
+    const rows = Object.entries(data).map(([ticker, sector]) => ({
+        symbol: ticker,
+        sector: sector || 'N/A'
+    }));
+
+    console.log(`✅ Found ${rows.length} mappings.`);
+
+    // 3. Initialize BigQuery
+    const bigquery = new BigQuery({ projectId: PROJECT_ID });
+    const dataset = bigquery.dataset(DATASET_ID);
+    const table = dataset.table(TABLE_ID);
+
+    // 4. Create Table (if not exists)
+    const schema = [
+        { name: 'symbol', type: 'STRING', mode: 'REQUIRED' },
+        { name: 'sector', type: 'STRING', mode: 'NULLABLE' }
+    ];
+
+    const [tableExists] = await table.exists();
+    
+    if (!tableExists) {
+        console.log(`Creating table ${TABLE_ID}...`);
+        await table.create({ schema });
+    } else {
+        console.log(`Table ${TABLE_ID} exists. Truncating...`);
+        // We truncate to ensure a clean slate (idempotent migration)
+        await bigquery.query(`TRUNCATE TABLE \`${PROJECT_ID}.${DATASET_ID}.${TABLE_ID}\``);
+    }
+
+    // 5. Insert Data
+    if (rows.length > 0) {
+        console.log('Inserting rows into BigQuery...');
+        // Insert in chunks to be safe
+        const chunkSize = 1000;
+        for (let i = 0; i < rows.length; i += chunkSize) {
+            const chunk = rows.slice(i, i + chunkSize);
+            await table.insert(chunk);
+            console.log(`  Inserted rows ${i + 1} to ${i + chunk.length}`);
+        }
+    }
+
+    console.log('🎉 Migration complete!');
+}
+
+migrate().catch(console.error);