aiden-shared-calculations-unified 1.0.7 → 1.0.9

package/calculations/pnl/average_daily_pnl_all_users.js

@@ -9,7 +9,7 @@ class AverageDailyPnlAllUsers {
         this.userCount = 0;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (!portfolioData || !portfolioData.AggregatedPositions || portfolioData.AggregatedPositions.length === 0) {
             return;
         }

package/calculations/pnl/average_daily_pnl_per_sector.js

@@ -9,7 +9,7 @@ class AverageDailyPnlPerSector {
         this.positions = [];
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (portfolioData && portfolioData.AggregatedPositions) {
             this.positions.push(...portfolioData.AggregatedPositions);
         }

package/calculations/pnl/average_daily_pnl_per_stock.js

@@ -10,7 +10,7 @@ class AverageDailyPnlPerStock {
         this.mappings = null;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
         if (!positions) {
             return;

package/calculations/pnl/average_daily_position_pnl.js

@@ -9,7 +9,7 @@ class AverageDailyPositionPnl {
         this.totalPositions = 0;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (portfolioData && portfolioData.AggregatedPositions) {
             for (const position of portfolioData.AggregatedPositions) {
                 this.totalNetProfit += position.NetProfit;

package/calculations/pnl/pnl_distribution_per_stock.js

@@ -1,53 +1,53 @@
-/**
- * @fileoverview Calculates the necessary components to determine the statistical variance of PnL for each stock,
- * serving as a proxy for crowd volatility.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class PnlDistributionPerStock {
-    constructor() {
-        this.distributionData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId, context) {
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions) return;
-
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            const netProfit = position.NetProfit;
-
-            if (!this.distributionData[instrumentId]) {
-                this.distributionData[instrumentId] = {
-                    pnl_sum: 0,
-                    pnl_sum_sq: 0,
-                    position_count: 0
-                };
-            }
-
-            this.distributionData[instrumentId].pnl_sum += netProfit;
-            this.distributionData[instrumentId].pnl_sum_sq += netProfit * netProfit;
-            this.distributionData[instrumentId].position_count++;
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.distributionData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.distributionData[instrumentId];
-        }
-        return { pnl_distribution_by_asset: result };
-    }
-
-    reset() {
-        this.distributionData = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * @fileoverview Calculates the necessary components to determine the statistical variance of PnL for each stock,
+ * serving as a proxy for crowd volatility.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class PnlDistributionPerStock {
+    constructor() {
+        this.distributionData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions) return;
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            const netProfit = position.NetProfit;
+
+            if (!this.distributionData[instrumentId]) {
+                this.distributionData[instrumentId] = {
+                    pnl_sum: 0,
+                    pnl_sum_sq: 0,
+                    position_count: 0
+                };
+            }
+
+            this.distributionData[instrumentId].pnl_sum += netProfit;
+            this.distributionData[instrumentId].pnl_sum_sq += netProfit * netProfit;
+            this.distributionData[instrumentId].position_count++;
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.distributionData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.distributionData[instrumentId];
+        }
+        return { pnl_distribution_by_asset: result };
+    }
+
+    reset() {
+        this.distributionData = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = PnlDistributionPerStock;

package/calculations/pnl/profitability_ratio_per_stock.js

@@ -1,51 +1,51 @@
-/**
- * @fileoverview Calculates the ratio of profitable vs. unprofitable positions for each stock.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class ProfitabilityRatioPerStock {
-    constructor() {
-        this.profitabilityData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId, context) {
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions) return;
-
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            const netProfit = position.NetProfit;
-
-            if (!this.profitabilityData[instrumentId]) {
-                this.profitabilityData[instrumentId] = { profitable: 0, unprofitable: 0 };
-            }
-
-            if (netProfit > 0) {
-                this.profitabilityData[instrumentId].profitable++;
-            } else if (netProfit < 0) {
-                this.profitabilityData[instrumentId].unprofitable++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.profitabilityData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.profitabilityData[instrumentId];
-        }
-        if (Object.keys(result).length === 0) return {};
-        return { profitability_by_asset: result };
-    }
-
-    reset() {
-        this.profitabilityData = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * @fileoverview Calculates the ratio of profitable vs. unprofitable positions for each stock.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class ProfitabilityRatioPerStock {
+    constructor() {
+        this.profitabilityData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions) return;
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            const netProfit = position.NetProfit;
+
+            if (!this.profitabilityData[instrumentId]) {
+                this.profitabilityData[instrumentId] = { profitable: 0, unprofitable: 0 };
+            }
+
+            if (netProfit > 0) {
+                this.profitabilityData[instrumentId].profitable++;
+            } else if (netProfit < 0) {
+                this.profitabilityData[instrumentId].unprofitable++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.profitabilityData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.profitabilityData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return { profitability_by_asset: result };
+    }
+
+    reset() {
+        this.profitabilityData = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = ProfitabilityRatioPerStock;

package/calculations/pnl/profitability_skew_per_stock.js

@@ -1,59 +1,59 @@
-/**
- * @fileoverview Calculates the magnitude of profitable vs. unprofitable positions for each stock,
- * providing insight into the skew of returns.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class ProfitabilitySkewPerStock {
-    constructor() {
-        this.skewData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId, context) {
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions) return;
-
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            const netProfit = position.NetProfit;
-
-            if (!this.skewData[instrumentId]) {
-                this.skewData[instrumentId] = {
-                    profit_sum: 0,
-                    loss_sum: 0,
-                    profitable_count: 0,
-                    unprofitable_count: 0
-                };
-            }
-
-            if (netProfit > 0) {
-                this.skewData[instrumentId].profit_sum += netProfit;
-                this.skewData[instrumentId].profitable_count++;
-            } else if (netProfit < 0) {
-                this.skewData[instrumentId].loss_sum += netProfit; // Keep it negative to sum up losses
-                this.skewData[instrumentId].unprofitable_count++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.skewData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.skewData[instrumentId];
-        }
-        if (Object.keys(result).length === 0) return {};
-        return { profitability_skew_by_asset: result };
-    }
-
-    reset() {
-        this.skewData = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * @fileoverview Calculates the magnitude of profitable vs. unprofitable positions for each stock,
+ * providing insight into the skew of returns.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class ProfitabilitySkewPerStock {
+    constructor() {
+        this.skewData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions) return;
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            const netProfit = position.NetProfit;
+
+            if (!this.skewData[instrumentId]) {
+                this.skewData[instrumentId] = {
+                    profit_sum: 0,
+                    loss_sum: 0,
+                    profitable_count: 0,
+                    unprofitable_count: 0
+                };
+            }
+
+            if (netProfit > 0) {
+                this.skewData[instrumentId].profit_sum += netProfit;
+                this.skewData[instrumentId].profitable_count++;
+            } else if (netProfit < 0) {
+                this.skewData[instrumentId].loss_sum += netProfit; // Keep it negative to sum up losses
+                this.skewData[instrumentId].unprofitable_count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.skewData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.skewData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return { profitability_skew_by_asset: result };
+    }
+
+    reset() {
+        this.skewData = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = ProfitabilitySkewPerStock;

package/calculations/sanity/users_processed.js

@@ -1,27 +1,27 @@
-/**
- * @fileoverview A simple counter that increments for each user processed.
- */
-
-class UsersProcessed {
-    constructor() {
-        this.userCount = 0;
-    }
-
-    process(portfolioData, userId, context) {
-        this.userCount++;
-    }
-
-    getResult() {
-        if (this.userCount === 0) return {};
-        // FIX: Rename the key to use the 'raw' prefix for correct aggregation.
-        return {
-            rawTotalUsersProcessed: this.userCount
-        };
-    }
-
-    reset() {
-        this.userCount = 0;
-    }
-}
-
+/**
+ * @fileoverview A simple counter that increments for each user processed.
+ */
+
+class UsersProcessed {
+    constructor() {
+        this.userCount = 0;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        this.userCount++;
+    }
+
+    getResult() {
+        if (this.userCount === 0) return {};
+        // FIX: Rename the key to use the 'raw' prefix for correct aggregation.
+        return {
+            rawTotalUsersProcessed: this.userCount
+        };
+    }
+
+    reset() {
+        this.userCount = 0;
+    }
+}
+
 module.exports = UsersProcessed;

package/calculations/sectors/total_long_per_sector.js

@@ -8,7 +8,7 @@ class TotalLongPerSector {
         this.longPositions = [];
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (portfolioData && portfolioData.AggregatedPositions) {
             for (const position of portfolioData.AggregatedPositions) {
                 if (position.Direction === 'Buy') {

package/calculations/sectors/total_short_per_sector.js

@@ -8,7 +8,7 @@ class TotalShortPerSector {
         this.shortPositions = [];
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (portfolioData && portfolioData.AggregatedPositions) {
             for (const position of portfolioData.AggregatedPositions) {
                 if (position.Direction === 'Sell') {

package/calculations/short_and_long_stats/long_position_per_stock.js

@@ -10,7 +10,7 @@ class LongPositionPerStock {
         this.mappings = null;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (!portfolioData || !portfolioData.AggregatedPositions) {
             return;
         }

package/calculations/short_and_long_stats/sentiment_per_stock.js

@@ -1,50 +1,50 @@
-/**
- * @fileoverview Calculates a crowd sentiment score for each instrument by counting long and short positions.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class SentimentPerStock {
-    constructor() {
-        this.sentimentData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId, context) {
-        if (!portfolioData || !portfolioData.AggregatedPositions) {
-            return;
-        }
-
-        for (const position of portfolioData.AggregatedPositions) {
-            const instrumentId = position.InstrumentID;
-            if (!this.sentimentData[instrumentId]) {
-                this.sentimentData[instrumentId] = { long_positions: 0, short_positions: 0 };
-            }
-
-            if (position.Direction === 'Buy') {
-                this.sentimentData[instrumentId].long_positions++;
-            } else if (position.Direction === 'Sell') {
-                this.sentimentData[instrumentId].short_positions++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.sentimentData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.sentimentData[instrumentId];
-        }
-        if (Object.keys(result).length === 0) return {};
-        return { sentiment_by_asset: result };
-    }
-
-    reset() {
-        this.sentimentData = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * @fileoverview Calculates a crowd sentiment score for each instrument by counting long and short positions.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class SentimentPerStock {
+    constructor() {
+        this.sentimentData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (!portfolioData || !portfolioData.AggregatedPositions) {
+            return;
+        }
+
+        for (const position of portfolioData.AggregatedPositions) {
+            const instrumentId = position.InstrumentID;
+            if (!this.sentimentData[instrumentId]) {
+                this.sentimentData[instrumentId] = { long_positions: 0, short_positions: 0 };
+            }
+
+            if (position.Direction === 'Buy') {
+                this.sentimentData[instrumentId].long_positions++;
+            } else if (position.Direction === 'Sell') {
+                this.sentimentData[instrumentId].short_positions++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.sentimentData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.sentimentData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return { sentiment_by_asset: result };
+    }
+
+    reset() {
+        this.sentimentData = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = SentimentPerStock;

package/calculations/short_and_long_stats/short_position_per_stock.js

@@ -9,7 +9,7 @@ class ShortPositionPerStock {
         this.mappings = null;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (!portfolioData || !portfolioData.AggregatedPositions) {
             return;
         }

package/calculations/short_and_long_stats/total_long_figures.js

@@ -7,7 +7,7 @@ class TotalLongFigures {
         this.totalLongPositions = 0;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (portfolioData && portfolioData.AggregatedPositions) {
             for (const position of portfolioData.AggregatedPositions) {
                 if (position.Direction === 'Buy') {

package/calculations/short_and_long_stats/total_short_figures.js

@@ -7,7 +7,7 @@ class TotalShortFigures {
         this.totalShortPositions = 0;
     }
 
-    process(portfolioData, userId, context) {
+    process(portfolioData, yesterdayPortfolio, userId, context) {
         if (portfolioData && portfolioData.AggregatedPositions) {
             for (const position of portfolioData.AggregatedPositions) {
                 // Note: Short positions are indicated by Direction: 'Sell' in this data model

package/calculations/socialPosts/social-asset-posts-trend.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Aggregates the total number of posts per asset (ticker).
+ * This data can be used for a time-series trend (AssetPostsTrend) or
+ * for a "Top Tickers" card.
+ * This calculation ONLY uses the social post insights context.
+ */
+
+class SocialAssetPostsTrend {
+    constructor() {
+        this.postsByTicker = {};
+        this.processed = false; // Flag to ensure this runs only once
+    }
+
+    /**
+     * @param {null} todayPortfolio - Not used.
+     * ... (other params not used) ...
+     * @param {object} todaySocialPostInsights - Map of { [postId]: postData } for today.
+     * @param {object} yesterdaySocialPostInsights - Not used.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, todaySocialPostInsights, yesterdaySocialPostInsights) {
+        
+        if (this.processed || !todaySocialPostInsights) {
+            return;
+        }
+        this.processed = true;
+
+        const posts = Object.values(todaySocialPostInsights);
+
+        for (const post of posts) {
+            if (!post.tickers || !Array.isArray(post.tickers)) continue;
+
+            for (const ticker of post.tickers) {
+                // Ensure ticker is a string and valid
+                const validTicker = String(ticker).trim();
+                if (validTicker) {
+                    this.postsByTicker[validTicker] = (this.postsByTicker[validTicker] || 0) + 1;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        // Returns an object like: { "AAPL": 15, "TSLA": 22 }
+        return this.postsByTicker;
+    }
+
+    reset() {
+        this.postsByTicker = {};
+        this.processed = false;
+    }
+}
+
+module.exports = SocialAssetPostsTrend;