aiden-shared-calculations-unified 1.0.90 → 1.0.92

package/calculations/core/asset-pnl-status.js

@@ -1,11 +1,13 @@
 /**
  * @fileoverview Core Metric (Pass 2)
- * REFACTORED: Buckets users by P&L status (Win/Loss).
+ * REFACTORED: Buckets P&L status by User Profile.
+ * - Pivots data to be User-Centric (User -> Winners/Losers).
+ * - Removes sharding complexity (fits within 1MB via structure optimization).
  */
 class AssetPnlStatus {
     constructor() {
-        this.tickerBuckets = new Map();
-        this.sectorBuckets = new Map();
+        // Map<UserId, { winners: Set<String>, losers: Set<String> }>
+        this.userStats = new Map();
     }
 
     static getMetadata() {
@@ -21,80 +23,92 @@ class AssetPnlStatus {
     static getDependencies() { return []; }
 
     static getSchema() {
-        const cohortSchema = {
-            "type": "object",
-            "properties": {
-                "winners": { "type": "array", "items": { "type": "string" } },
-                "losers": { "type": "array", "items": { "type": "string" } }
-            },
-            "required": ["winners", "losers"]
-        };
         return {
             "type": "object",
             "properties": {
-                "by_ticker": { "type": "object", "patternProperties": { "^.*$": cohortSchema } },
-                "by_sector": { "type": "object", "patternProperties": { "^.*$": cohortSchema } }
+                "by_user": {
+                    "type": "object",
+                    "description": "Map of User IDs to their winning/losing assets and sectors.",
+                    "patternProperties": {
+                        "^[0-9]+$": { // Matches User IDs (CIDs)
+                            "type": "object",
+                            "properties": {
+                                "winners": { "type": "array", "items": { "type": "string" } },
+                                "losers": { "type": "array", "items": { "type": "string" } }
+                            },
+                            "required": ["winners", "losers"]
+                        }
+                    }
+                }
             }
         };
     }
     
-    _init(map, key) {
-        if (!map.has(key)) map.set(key, { winners: new Set(), losers: new Set() });
+    _initUser(userId) {
+        if (!this.userStats.has(userId)) {
+            this.userStats.set(userId, { winners: new Set(), losers: new Set() });
+        }
+        return this.userStats.get(userId);
     }
 
     process(context) {
         const { extract } = context.math;
         const { mappings, user } = context;
+        const userId = user.id;
 
+        // 1. Get Positions using the standard extractor
         const positions = extract.getPositions(user.portfolio.today, user.type);
+        if (!positions || positions.length === 0) return;
+
+        // 2. Lazy init stats only if needed
+        let stats = null;
 
         for (const pos of positions) {
             const instId = extract.getInstrumentId(pos);
             if (!instId) continue;
             
             const pnl = extract.getNetProfit(pos);
-            if (pnl === 0) continue;
+            if (pnl === 0) continue; // Ignore flat positions
             
             const ticker = mappings.instrumentToTicker[instId];
             const sector = mappings.instrumentToSector[instId];
             const isWinner = pnl > 0;
 
-            if (ticker) {
-                this._init(this.tickerBuckets, ticker);
-                const asset = this.tickerBuckets.get(ticker);
-                if (isWinner) asset.winners.add(user.id);
-                else asset.losers.add(user.id);
-            }
-            
-            if (sector) {
-                this._init(this.sectorBuckets, sector);
-                const sec = this.sectorBuckets.get(sector);
-                if (isWinner) sec.winners.add(user.id);
-                else sec.losers.add(user.id);
+            if (ticker || sector) {
+                if (!stats) stats = this._initUser(userId);
+
+                if (ticker) {
+                    if (isWinner) stats.winners.add(ticker);
+                    else stats.losers.add(ticker);
+                }
+                
+                if (sector) {
+                    if (isWinner) stats.winners.add(sector);
+                    else stats.losers.add(sector);
+                }
             }
         }
     }
 
     async getResult() {
-        const result = { by_ticker: {}, by_sector: {} };
-        
-        const buildResult = (map, out) => {
-            for (const [key, data] of map.entries()) {
-                out[key] = {
-                    winners: Array.from(data.winners),
-                    losers: Array.from(data.losers)
+        const byUser = {};
+
+        for (const [userId, stats] of this.userStats) {
+            // Only include users who actually have relevant P&L data
+            if (stats.winners.size > 0 || stats.losers.size > 0) {
+                byUser[userId] = {
+                    winners: Array.from(stats.winners),
+                    losers: Array.from(stats.losers)
                 };
             }
-        };
+        }
 
-        buildResult(this.tickerBuckets, result.by_ticker);
-        buildResult(this.sectorBuckets, result.by_sector);
-        return result;
+        return { by_user: byUser };
     }
     
     reset() {
-        this.tickerBuckets.clear();
-        this.sectorBuckets.clear();
+        this.userStats.clear();
     }
 }
+
 module.exports = AssetPnlStatus;

package/calculations/core/instrument-price-change-1d.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for 1-day price change.
- * REFACTORED: Uses process(context) solely.
+ * FIXED: Uses priceExtractor properly
  */
 class InstrumentPriceChange1D {
     constructor() {
@@ -29,41 +29,37 @@ class InstrumentPriceChange1D {
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
-
-    _getPrices(priceData) {
-        if (!priceData || !priceData.prices) return [];
-        return Object.entries(priceData.prices)
-            .map(([date, price]) => ({ date, price }))
-            .sort((a, b) => new Date(a.date) - new Date(b.date));
-    }
     
     process(context) {
-        const { mappings, prices } = context;
+        const { mappings, prices, date, math } = context;
         const { instrumentToTicker } = mappings;
+        const { priceExtractor } = math;
         
-        // Expecting context.prices to be populated by the controller for 'meta' + 'price' dependency
-        const todayPrices = prices?.today || [];
-        const yesterdayPrices = prices?.yesterday || [];
-
-        const results = {};
+        if (!prices || !prices.history) {
+            this.result = {};
+            return;
+        }
 
-        const todayPriceMap = new Map(todayPrices.map(p => {
-            const pList = this._getPrices(p);
-            const lastPrice = pList.length > 0 ? pList[pList.length - 1].price : 0;
-            return [p.instrumentId, lastPrice];
-        }));
+        const todayStr = date.today;
+        const todayDate = new Date(todayStr + 'T00:00:00Z');
+        const yesterdayDate = new Date(todayDate);
+        yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
+        const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
 
-        const yesterdayPriceMap = new Map(yesterdayPrices.map(p => {
-            const pList = this._getPrices(p);
-            const lastPrice = pList.length > 0 ? pList[pList.length - 1].price : 0;
-            return [p.instrumentId, lastPrice];
-        }));
+        const results = {};
 
-        for (const [instrumentId, todayPrice] of todayPriceMap) {
-            const yesterdayPrice = yesterdayPriceMap.get(instrumentId);
+        // Iterate over all instruments in price history
+        for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
 
+            const history = priceExtractor.getHistory(prices, instrumentId);
+            if (history.length === 0) continue;
+
+            // Find today's and yesterday's prices
+            const todayPrice = priceData.prices?.[todayStr];
+            const yesterdayPrice = priceData.prices?.[yesterdayStr];
+
             if (todayPrice && yesterdayPrice && yesterdayPrice > 0) {
                 const changePct = ((todayPrice - yesterdayPrice) / yesterdayPrice) * 100;
                 results[ticker] = {
@@ -73,6 +69,7 @@ class InstrumentPriceChange1D {
                 results[ticker] = { change_1d_pct: 0 };
             }
         }
+        
         this.result = results;
     }
 

package/calculations/core/instrument-price-momentum-20d.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for 20-day momentum.
- * REFACTORED: Uses process(context) solely.
+ * FIXED: Uses priceExtractor properly
  */
 class InstrumentPriceMomentum20D {
     constructor() {
@@ -30,13 +30,14 @@ class InstrumentPriceMomentum20D {
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    _findPriceOnOrBefore(priceHistoryObj, targetDateStr) {
-        if (!priceHistoryObj || !priceHistoryObj.prices) return null;
+    _findPriceOnOrBefore(prices, instrumentId, targetDateStr) {
+        const priceData = prices.history[instrumentId];
+        if (!priceData || !priceData.prices) return null;
         
         let checkDate = new Date(targetDateStr + 'T00:00:00Z');
         for (let i = 0; i < 5; i++) { 
             const str = checkDate.toISOString().slice(0, 10);
-            const price = priceHistoryObj.prices[str];
+            const price = priceData.prices[str];
             if (price !== undefined && price !== null && price > 0) return price;
             checkDate.setUTCDate(checkDate.getUTCDate() - 1);
         }
@@ -47,8 +48,10 @@ class InstrumentPriceMomentum20D {
         const { mappings, prices, date } = context;
         const { instrumentToTicker } = mappings;
         
-        // Use historical price data available in context
-        const priceData = prices?.history || []; 
+        if (!prices || !prices.history) {
+            this.result = {};
+            return;
+        }
         
         const todayStr = date.today;
         const todayDate = new Date(todayStr + 'T00:00:00Z');
@@ -58,13 +61,13 @@ class InstrumentPriceMomentum20D {
 
         const results = {};
 
-        for (const p of priceData) {
-            const instrumentId = p.instrumentId;
+        // Iterate over all instruments in price history
+        for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
 
-            const currentPrice = this._findPriceOnOrBefore(p, todayStr);
-            const oldPrice = this._findPriceOnOrBefore(p, oldStr);
+            const currentPrice = this._findPriceOnOrBefore(prices, instrumentId, todayStr);
+            const oldPrice = this._findPriceOnOrBefore(prices, instrumentId, oldStr);
 
             if (currentPrice && oldPrice && oldPrice > 0) {
                 const momPct = ((currentPrice - oldPrice) / oldPrice) * 100;
@@ -75,6 +78,7 @@ class InstrumentPriceMomentum20D {
                 results[ticker] = { momentum_20d_pct: 0 };
             }
         }
+        
         this.result = results;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.90",
+  "version": "1.0.92",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [

package/utils/firestore_utils.js

@@ -41,7 +41,6 @@ async function withRetry(asyncOperation, operationName = 'Firestore operation')
             const code = error.code || error.details;
 
             if (RETRYABLE_ERROR_CODES.has(code)) {
-                // Assuming logger is available globally or passed in somehow in the package context
                 if (typeof logger !== 'undefined' && logger.log) {
                     logger.log('WARN', `[Retry ${attempt}/${MAX_RETRIES}] Retrying ${operationName} due to ${code}. Waiting ${backoff}ms...`);
                 } else {