aiden-shared-calculations-unified 1.0.34 → 1.0.36

package/calculations/speculators/historical/tsl_effectiveness.js

@@ -1,75 +1,75 @@
-/**
- * Compares the average P/L of speculator users who use TSL
- * vs. those who do not.
- */
-class TslEffectiveness {
-    constructor() {
-        this.tsl_group = { pnl_sum: 0, count: 0 };
-        this.nontsl_group = { pnl_sum: 0, count: 0 };
-    }
-
-    /**
-     * FIX: Helper function to calculate total P&L from positions
-     * @param {object} portfolio
-     * @returns {number|null}
-     */
-    _calculateTotalPnl(portfolio) {
-        // Speculators use PublicPositions
-        const positions = portfolio?.PublicPositions;
-        if (positions && Array.isArray(positions)) {
-            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
-            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
-        }
-        return null;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        // Check if user is a speculator and we have today's data
-        // FIX: yesterdayPortfolio is not needed for this logic, only today's P&L
-        if (todayPortfolio?.context?.userType !== 'speculator' || !todayPortfolio) {
-            return;
-        }
-        
-        const positions = todayPortfolio.PublicPositions;
-        
-        if (!positions || !Array.isArray(positions)) {
-            return; 
-        }
-
-        // FIX: Calculate dailyPnl by summing NetProfit from all positions
-        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
-
-        if (dailyPnl === null) {
-            return; // Cannot calculate P&L
-        }
-        
-        const usesTSL = positions.some(p => p.IsTslEnabled);
-
-        if (usesTSL) {
-            this.tsl_group.pnl_sum += dailyPnl;
-            this.tsl_group.count++;
-        } else {
-            this.nontsl_group.pnl_sum += dailyPnl;
-            this.nontsl_group.count++;
-        }
-    }
-
-    getResult() {
-        // Return final calculated averages
-        const tsl_avg_pnl = (this.tsl_group.count > 0) ? this.tsl_group.pnl_sum / this.tsl_group.count : 0;
-        const nontsl_avg_pnl = (this.nontsl_group.count > 0) ? this.nontsl_group.pnl_sum / this.nontsl_group.count : 0;
-
-        return {
-            tsl_users: {
-                avg_pnl: tsl_avg_pnl,
-                count: this.tsl_group.count
-            },
-            nontsl_users: {
-                avg_pnl: nontsl_avg_pnl,
-                count: this.nontsl_group.count
-            }
-        };
-    }
-}
-
+/**
+ * Compares the average P/L of speculator users who use TSL
+ * vs. those who do not.
+ */
+class TslEffectiveness {
+    constructor() {
+        this.tsl_group = { pnl_sum: 0, count: 0 };
+        this.nontsl_group = { pnl_sum: 0, count: 0 };
+    }
+
+    /**
+     * FIX: Helper function to calculate total P&L from positions
+     * @param {object} portfolio
+     * @returns {number|null}
+     */
+    _calculateTotalPnl(portfolio) {
+        // Speculators use PublicPositions
+        const positions = portfolio?.PublicPositions;
+        if (positions && Array.isArray(positions)) {
+            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
+            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
+        }
+        return null;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // Check if user is a speculator and we have today's data
+        // FIX: yesterdayPortfolio is not needed for this logic, only today's P&L
+        if (todayPortfolio?.context?.userType !== 'speculator' || !todayPortfolio) {
+            return;
+        }
+        
+        const positions = todayPortfolio.PublicPositions;
+        
+        if (!positions || !Array.isArray(positions)) {
+            return; 
+        }
+
+        // FIX: Calculate dailyPnl by summing NetProfit from all positions
+        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
+
+        if (dailyPnl === null) {
+            return; // Cannot calculate P&L
+        }
+        
+        const usesTSL = positions.some(p => p.IsTslEnabled);
+
+        if (usesTSL) {
+            this.tsl_group.pnl_sum += dailyPnl;
+            this.tsl_group.count++;
+        } else {
+            this.nontsl_group.pnl_sum += dailyPnl;
+            this.nontsl_group.count++;
+        }
+    }
+
+    getResult() {
+        // Return final calculated averages
+        const tsl_avg_pnl = (this.tsl_group.count > 0) ? this.tsl_group.pnl_sum / this.tsl_group.count : 0;
+        const nontsl_avg_pnl = (this.nontsl_group.count > 0) ? this.nontsl_group.pnl_sum / this.nontsl_group.count : 0;
+
+        return {
+            tsl_users: {
+                avg_pnl: tsl_avg_pnl,
+                count: this.tsl_group.count
+            },
+            nontsl_users: {
+                avg_pnl: nontsl_avg_pnl,
+                count: this.nontsl_group.count
+            }
+        };
+    }
+}
+
 module.exports = TslEffectiveness;

package/index.js

@@ -1,33 +1,33 @@
-/**
- * index.js
- * Main entry point for the Unified Calculations package.
- *
- * This file uses require-all to export all calculations dynamically
- * from their respective subdirectories. It also manually exports utility
- * functions for use within the calculations.
- */
-
-const requireAll = require('require-all');
-const path = require('path');
-
-// --- Utils (Manually Exported) ---
-const firestoreUtils = require('./utils/firestore_utils');
-const mappingProvider = require('./utils/sector_mapping_provider');
-const priceProvider = require('./utils/price_data_provider'); // <-- ADD THIS
-
-// --- Calculations (Dynamically Loaded) ---
-const calculations = requireAll({
-    dirname: path.join(__dirname, 'calculations'), // Use __dirname to get the correct path
-    filter: /(.+)\.js$/,                            // Only load .js files
-    recursive: true,                                // Load from subdirectories
-    map: name => name.replace(/_/g, '-')          // Convert snake_case filenames to kebab-case keys
-});
-
-module.exports = {
-    calculations,
-    utils: {
-        ...firestoreUtils,
-        ...mappingProvider,
-        ...priceProvider // <-- ADD THIS
-    }
-};
+/**
+ * index.js
+ * Main entry point for the Unified Calculations package.
+ *
+ * This file uses require-all to export all calculations dynamically
+ * from their respective subdirectories. It also manually exports utility
+ * functions for use within the calculations.
+ */
+
+const requireAll = require('require-all');
+const path = require('path');
+
+// --- Utils (Manually Exported) ---
+const firestoreUtils = require('./utils/firestore_utils');
+const mappingProvider = require('./utils/sector_mapping_provider');
+const priceProvider = require('./utils/price_data_provider'); // <-- ADD THIS
+
+// --- Calculations (Dynamically Loaded) ---
+const calculations = requireAll({
+    dirname: path.join(__dirname, 'calculations'), // Use __dirname to get the correct path
+    filter: /(.+)\.js$/,                            // Only load .js files
+    recursive: true,                                // Load from subdirectories
+    map: name => name.replace(/_/g, '-')          // Convert snake_case filenames to kebab-case keys
+});
+
+module.exports = {
+    calculations,
+    utils: {
+        ...firestoreUtils,
+        ...mappingProvider,
+        ...priceProvider // <-- ADD THIS
+    }
+};

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "aiden-shared-calculations-unified",
-  "version": "1.0.34",
-  "description": "Shared calculation modules for the BullTrackers Computation System.",
-  "main": "index.js",
-  "files": [
-    "index.js",
-    "calculations/",
-    "utils/"
-  ],
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "bulltrackers",
-    "etoro",
-    "precompute",
-    "calculations",
-    "finance"
-  ],
-  "dependencies": {
-    "@google-cloud/firestore": "^7.11.3",
-    "sharedsetup": "latest",
-    "require-all": "^3.0.0"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "aiden-shared-calculations-unified",
+  "version": "1.0.36",
+  "description": "Shared calculation modules for the BullTrackers Computation System.",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "calculations/",
+    "utils/"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "bulltrackers",
+    "etoro",
+    "precompute",
+    "calculations",
+    "finance"
+  ],
+  "dependencies": {
+    "@google-cloud/firestore": "^7.11.3",
+    "sharedsetup": "latest",
+    "require-all": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/utils/firestore_utils.js

@@ -1,77 +1,77 @@
-/**
- * @fileoverview Provides a resilient retry wrapper for Firestore operations.
- */
-const { logger } = require("sharedsetup")(__filename); // Note: In the package, you might need to adjust how the logger is obtained if sharedsetup isn't a direct dependency or passed in.
-
-// Firestore error codes that are safe to retry
-const RETRYABLE_ERROR_CODES = new Set([
-    'DEADLINE_EXCEEDED',
-    'UNAVAILABLE',
-    'INTERNAL',
-    'RESOURCE_EXHAUSTED', // Can indicate contention
-]);
-
-const MAX_RETRIES = 5;
-const INITIAL_BACKOFF_MS = 1000;
-
-/**
- * Delays execution for a specified number of milliseconds.
- * @param {number} ms The number of milliseconds to wait.
- * @returns {Promise<void>}
- */
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
-/**
- * Wraps an asynchronous Firestore operation with an exponential backoff retry mechanism.
- *
- * @param {() => Promise<T>} asyncOperation The async function to execute.
- * @param {string} operationName A descriptive name for the operation (for logging).
- * @returns {Promise<T>} The result of the async operation.
- * @template T
- */
-async function withRetry(asyncOperation, operationName = 'Firestore operation') {
-    let lastError = null;
-    let backoff = INITIAL_BACKOFF_MS;
-
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-            return await asyncOperation();
-        } catch (error) {
-            lastError = error;
-            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 {
-                    console.warn(`[Retry ${attempt}/${MAX_RETRIES}] Retrying ${operationName} due to ${code}. Waiting ${backoff}ms...`);
-                }
-                await sleep(backoff);
-                backoff *= 2; // Exponential backoff
-            } else {
-                 if (typeof logger !== 'undefined' && logger.log) {
-                    logger.log('ERROR', `[Retry] Non-retryable error during ${operationName}: ${code}`, { errorMessage: error.message });
-                 } else {
-                     console.error(`[Retry] Non-retryable error during ${operationName}: ${code}`, { errorMessage: error.message });
-                 }
-                throw error; // Not a retryable error, re-throw immediately
-            }
-        }
-    }
-
-     if (typeof logger !== 'undefined' && logger.log) {
-        logger.log('ERROR', `[Retry] ${operationName} failed after ${MAX_RETRIES} attempts.`, {
-            finalErrorCode: lastError?.code || lastError?.details, // Added safe navigation
-            errorMessage: lastError?.message // Added safe navigation
-        });
-     } else {
-         console.error(`[Retry] ${operationName} failed after ${MAX_RETRIES} attempts.`, {
-            finalErrorCode: lastError?.code || lastError?.details,
-            errorMessage: lastError?.message
-        });
-     }
-    throw lastError; // All retries failed, throw the last error
-}
-
+/**
+ * @fileoverview Provides a resilient retry wrapper for Firestore operations.
+ */
+const { logger } = require("sharedsetup")(__filename); // Note: In the package, you might need to adjust how the logger is obtained if sharedsetup isn't a direct dependency or passed in.
+
+// Firestore error codes that are safe to retry
+const RETRYABLE_ERROR_CODES = new Set([
+    'DEADLINE_EXCEEDED',
+    'UNAVAILABLE',
+    'INTERNAL',
+    'RESOURCE_EXHAUSTED', // Can indicate contention
+]);
+
+const MAX_RETRIES = 5;
+const INITIAL_BACKOFF_MS = 1000;
+
+/**
+ * Delays execution for a specified number of milliseconds.
+ * @param {number} ms The number of milliseconds to wait.
+ * @returns {Promise<void>}
+ */
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Wraps an asynchronous Firestore operation with an exponential backoff retry mechanism.
+ *
+ * @param {() => Promise<T>} asyncOperation The async function to execute.
+ * @param {string} operationName A descriptive name for the operation (for logging).
+ * @returns {Promise<T>} The result of the async operation.
+ * @template T
+ */
+async function withRetry(asyncOperation, operationName = 'Firestore operation') {
+    let lastError = null;
+    let backoff = INITIAL_BACKOFF_MS;
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            return await asyncOperation();
+        } catch (error) {
+            lastError = error;
+            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 {
+                    console.warn(`[Retry ${attempt}/${MAX_RETRIES}] Retrying ${operationName} due to ${code}. Waiting ${backoff}ms...`);
+                }
+                await sleep(backoff);
+                backoff *= 2; // Exponential backoff
+            } else {
+                 if (typeof logger !== 'undefined' && logger.log) {
+                    logger.log('ERROR', `[Retry] Non-retryable error during ${operationName}: ${code}`, { errorMessage: error.message });
+                 } else {
+                     console.error(`[Retry] Non-retryable error during ${operationName}: ${code}`, { errorMessage: error.message });
+                 }
+                throw error; // Not a retryable error, re-throw immediately
+            }
+        }
+    }
+
+     if (typeof logger !== 'undefined' && logger.log) {
+        logger.log('ERROR', `[Retry] ${operationName} failed after ${MAX_RETRIES} attempts.`, {
+            finalErrorCode: lastError?.code || lastError?.details, // Added safe navigation
+            errorMessage: lastError?.message // Added safe navigation
+        });
+     } else {
+         console.error(`[Retry] ${operationName} failed after ${MAX_RETRIES} attempts.`, {
+            finalErrorCode: lastError?.code || lastError?.details,
+            errorMessage: lastError?.message
+        });
+     }
+    throw lastError; // All retries failed, throw the last error
+}
+
 module.exports = { withRetry, sleep };