bulltrackers-module 1.0.211 → 1.0.213

package/functions/computation-system/layers/extractors.js

@@ -0,0 +1,279 @@
+/**
+ * @fileoverview Extractors Layer
+ * Core access methods to raw data.
+ * FIX: HistoryExtractor handles both Legacy and Modern (Granular) schemas.
+ */
+
+const { SCHEMAS } = require('./profiling');
+
+class TradeSeriesBuilder {
+    static buildReturnSeries(historyTrades) {
+        if (!historyTrades || !Array.isArray(historyTrades)) return [];
+        const closedTrades = historyTrades.filter(t => t.CloseDateTime && typeof t.NetProfit === 'number');
+        closedTrades.sort((a, b) => new Date(a.CloseDateTime) - new Date(b.CloseDateTime));
+        return closedTrades.map(t => t.NetProfit);
+    }
+
+    static buildCumulativeCurve(returnSeries, startValue = 100) {
+        const curve = [startValue];
+        let current = startValue;
+        for (const ret of returnSeries) {
+            current = current * (1 + (ret / 100));
+            curve.push(current);
+        }
+        return curve;
+    }
+}
+
+class DataExtractor { 
+    static getPositions(portfolio, userType) {
+        if (!portfolio) return []; 
+        if (userType === SCHEMAS.USER_TYPES.SPECULATOR) { 
+            return portfolio.PublicPositions || []; 
+        }
+        return portfolio.AggregatedPositions || [];
+    }
+
+    static getInstrumentId(position) {
+        if (!position) return null; 
+        return position.InstrumentID || position.instrumentId || null;
+    }
+
+    static getPositionId(position) {
+        if (!position) return null; 
+        if (position.PositionID) return String(position.PositionID);
+        if (position.PositionId) return String(position.PositionId);
+        const instId = this.getInstrumentId(position);
+        const dir    = this.getDirection(position);
+        if (instId) return `${instId}_${dir}`;
+        return null;
+    }
+
+    static getNetProfit(position) { 
+        return position ? (position.NetProfit || 0) : 0;
+    }
+
+    static getPositionWeight(position, userType) { 
+        if (!position) return 0;
+        return position.Invested || position.Amount || 0;
+    }
+
+    static getPositionValuePct(position) {            
+        return position ? (position.Value || 0) : 0; 
+    }
+
+    static deriveEntryPrice(currentPrice, netProfitPct) {
+        if (!currentPrice || currentPrice <= 0) return 0;
+        if (netProfitPct <= -100) return Number.MAX_SAFE_INTEGER; 
+        return currentPrice / (1 + (netProfitPct / 100.0));
+    }
+
+    static getPortfolioDailyPnl(portfolio, userType) {
+        if (!portfolio) return 0;
+        if (userType === SCHEMAS.USER_TYPES.SPECULATOR) {       
+            return portfolio.NetProfit || 0;                    
+        }
+        if (portfolio.AggregatedPositionsByInstrumentTypeID) {
+            return portfolio.AggregatedPositionsByInstrumentTypeID.reduce((sum, agg) => {
+                return sum + ((agg.Value || 0) - (agg.Invested || 0));
+            }, 0);
+        }
+        return 0;
+    }
+
+    static getDirection(position) {
+        if (!position) return "Buy";
+        if (position.Direction) return position.Direction;
+        if (typeof position.IsBuy === 'boolean') return position.IsBuy ? "Buy" : "Sell";
+        return "Buy"; 
+    }
+
+    static getLeverage(position) { return position ? (position.Leverage || 1) : 1; }
+    static getOpenRate(position) { return position ? (position.OpenRate || 0) : 0; }
+    static getCurrentRate(position) { return position ? (position.CurrentRate || 0) : 0; }
+    static getStopLossRate(position) {
+        const rate = position ? (position.StopLossRate || 0) : 0; 
+        if (rate > 0 && rate <= 0.01) return 0; 
+        if (rate < 0) return 0;
+        return rate;
+    }                                                       
+    static getTakeProfitRate(position) {
+        const rate = position ? (position.TakeProfitRate || 0) : 0;
+        if (rate > 0 && rate <= 0.01) return 0; 
+        return rate;
+    }
+    static getHasTSL(position) { return position ? (position.HasTrailingStopLoss === true) : false; }
+    static getOpenDateTime(position) { return (!position || !position.OpenDateTime) ? null : new Date(position.OpenDateTime); }
+}
+
+class priceExtractor {
+    static getHistory(pricesContext, tickerOrId) {
+        if (!pricesContext || !pricesContext.history) return [];
+        let assetData = pricesContext.history[tickerOrId];
+        
+        if (!assetData) {
+            const id = Object.keys(pricesContext.history).find(key => {
+                const data = pricesContext.history[key];
+                return data.ticker === tickerOrId;
+            });
+            if (id) assetData = pricesContext.history[id];
+        }
+
+        if (!assetData || !assetData.prices) return [];
+        const priceMap = assetData.prices;
+        const sortedDates = Object.keys(priceMap).sort((a, b) => a.localeCompare(b));
+        
+        return sortedDates.map(date => ({
+            date: date,
+            price: priceMap[date]
+        })).filter(item => item.price > 0);
+    }
+
+    static getAllHistories(pricesContext) {
+        if (!pricesContext || !pricesContext.history) return new Map();
+        const results = new Map();
+        for (const [id, data] of Object.entries(pricesContext.history)) {
+            const ticker = data.ticker || id;
+            const history = this.getHistory(pricesContext, id);
+            if (history.length > 0) results.set(ticker, history);
+        }
+        return results;
+    }
+}
+
+class HistoryExtractor {
+    static getDailyHistory(user) {
+        return user?.history?.today || null;
+    }
+
+    static getTradedAssets(historyDoc) {
+        // 1. Try Modern Granular Data (Derive Assets from Trades)
+        if (historyDoc?.PublicHistoryPositions?.length) {
+            const trades = historyDoc.PublicHistoryPositions;
+            const assetsMap = new Map();
+            
+            for (const t of trades) {
+                const instId = t.InstrumentID;
+                if (!instId) continue;
+                
+                if (!assetsMap.has(instId)) {
+                    assetsMap.set(instId, { 
+                        instrumentId: instId, 
+                        totalDuration: 0, 
+                        count: 0 
+                    });
+                }
+                
+                const asset = assetsMap.get(instId);
+                const open = new Date(t.OpenDateTime);
+                const close = new Date(t.CloseDateTime);
+                const durationMins = (close - open) / 60000;
+                
+                if (durationMins > 0) {
+                    asset.totalDuration += durationMins;
+                    asset.count++;
+                }
+            }
+            return Array.from(assetsMap.values()).map(a => ({
+                instrumentId: a.instrumentId,
+                avgHoldingTimeInMinutes: a.count > 0 ? (a.totalDuration / a.count) : 0
+            }));
+        }
+
+        // 2. Fallback to Legacy 'assets' array
+        if (historyDoc?.assets && Array.isArray(historyDoc.assets)) {
+            return historyDoc.assets;
+        }
+
+        return [];
+    }
+
+    static getInstrumentId(asset) { 
+        return asset ? asset.instrumentId : null;
+    }
+
+    static getAvgHoldingTimeMinutes(asset) { 
+        return asset ? (asset.avgHoldingTimeInMinutes || 0) : 0;
+    }
+
+    static getSummary(historyDoc) { 
+        // 1. Try Modern Granular Data (Derive Summary)
+        if (historyDoc?.PublicHistoryPositions?.length) {
+            const trades = historyDoc.PublicHistoryPositions;
+            let totalTrades = trades.length;
+            let wins = 0;
+            let totalProf = 0;
+            let totalLoss = 0;
+            let profCount = 0;
+            let lossCount = 0;
+            let totalDur = 0;
+
+            for (const t of trades) {
+                if (t.NetProfit > 0) {
+                    wins++;
+                    totalProf += t.NetProfit;
+                    profCount++;
+                } else if (t.NetProfit < 0) {
+                    totalLoss += t.NetProfit;
+                    lossCount++;
+                }
+                const open = new Date(t.OpenDateTime);
+                const close = new Date(t.CloseDateTime);
+                totalDur += (close - open) / 60000;
+            }
+
+            return { 
+                totalTrades:             totalTrades,
+                winRatio:                totalTrades > 0 ? (wins / totalTrades) * 100 : 0,
+                avgProfitPct:            profCount > 0 ? totalProf / profCount : 0,
+                avgLossPct:              lossCount > 0 ? totalLoss / lossCount : 0,
+                avgHoldingTimeInMinutes: totalTrades > 0 ? totalDur / totalTrades : 0
+            };
+        }
+
+        // 2. Fallback to Legacy 'all' object
+        if (historyDoc?.all) {
+            return historyDoc.all;
+        }
+
+        return null;
+    }
+}
+
+class InsightsExtractor {
+    static getInsights(context) {
+        return context.insights || context.daily_instrument_insights || [];
+    }
+
+    static getInsightForInstrument(insights, instrumentId) {
+        if (!insights || !Array.isArray(insights)) return null;
+        return insights.find(i => i.instrumentId === instrumentId) || null;
+    }
+
+    static getTotalOwners(insight) { return insight ? (insight.total || 0) : 0; }
+    static getLongPercent(insight) { return insight ? (insight.buy || 0) : 0; }
+    static getShortPercent(insight) { return insight ? (insight.sell || 0) : 0; }
+    static getGrowthPercent(insight) { return insight ? (insight.growth || 0) : 0; }
+
+    static getLongCount(insight) {
+        const total = this.getTotalOwners(insight);
+        const buyPct = this.getLongPercent(insight);
+        return Math.floor(total * (buyPct / 100));
+    }
+
+    static getShortCount(insight) {
+        const total = this.getTotalOwners(insight);
+        const sellPct = this.getShortPercent(insight);
+        return Math.floor(total * (sellPct / 100));
+    }
+
+    static getNetOwnershipChange(insight) {
+        const total = this.getTotalOwners(insight);
+        const growth = this.getGrowthPercent(insight);
+        if (total === 0) return 0;
+        const prevTotal = total / (1 + (growth / 100)); 
+        return Math.round(total - prevTotal);
+    }
+}
+
+module.exports = { DataExtractor, priceExtractor, HistoryExtractor, InsightsExtractor, TradeSeriesBuilder };

package/functions/computation-system/layers/index.js

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Layers Barrel File
+ * Aggregates all mathematical, extractor, and profiling primitives.
+ * Utilizes require-all to dynamically load new modules added to this directory.
+ */
+
+const requireAll = require('require-all');
+
+// 1. Manually Require Core Modules to ensure order and presence
+const profiling   = require('./profiling');
+const extractors  = require('./extractors');
+const mathematics = require('./mathematics');
+const validators  = require('./validators');
+
+// 2. Aggregate explicit exports
+const coreExports = {
+    ...profiling,
+    ...extractors,
+    ...mathematics,
+    ...validators
+};
+
+// 3. Dynamic Loading (Optional/Future-Proofing)
+// This loads any OTHER file in this directory that wasn't manually required above.
+const dynamicModules = requireAll({
+    dirname: __dirname,
+    filter: /^(?!index\.js$|profiling\.js$|extractors\.js$|mathematics\.js$|validators\.js$).+\.js$/, 
+    resolve: (mod) => mod
+});
+
+// Flatten dynamic modules into the export object
+const dynamicExports = {};
+Object.values(dynamicModules).forEach(moduleExports => {
+    Object.assign(dynamicExports, moduleExports);
+});
+
+module.exports = {
+    ...coreExports,
+    ...dynamicExports
+};