aiden-shared-calculations-unified 1.0.34 → 1.0.36

package/utils/price_data_provider.js

@@ -1,142 +1,142 @@
-const { Firestore } = require('@google-cloud/firestore');
-const firestore = new Firestore();
-
-// Config
-const PRICE_COLLECTION = 'asset_prices';
-const CACHE_DURATION_MS = 3600000; // 1 hour
-
-// Cache
-let cache = {
-  timestamp: null,
-  priceMap: null, // Will be { instrumentId: { "YYYY-MM-DD": price, ... } }
-};
-
-// In-progress fetch promise
-let fetchPromise = null;
-
-/**
- * Finds the most recent available price on or before a given date.
- * @param {object} priceHistory - The map of { "YYYY-MM-DD": price }
- * @param {string} dateStr - The target date string to start searching from.
- * @param {number} [maxLookback=5] - Max days to look back (to skip weekends/holidays).
- * @returns {number|null} The price, or null if not found.
- */
-function _findPreviousAvailablePrice(priceHistory, dateStr, maxLookback = 5) {
-    if (!priceHistory) return null;
-
-    let checkDate = new Date(dateStr + 'T00:00:00Z');
-    
-    for (let i = 0; i < maxLookback; i++) {
-        const checkDateStr = checkDate.toISOString().slice(0, 10);
-        const price = priceHistory[checkDateStr];
-        
-        if (price !== undefined && price !== null && price > 0) {
-            return price; // Found it
-        }
-        
-        // If not found, look back one more day
-        checkDate.setUTCDate(checkDate.getUTCDate() - 1);
-    }
-    
-    // console.warn(`No price found for instrument within ${maxLookback} days of ${dateStr}`);
-    return null; // No price found within lookback
-}
-
-/**
- * Loads all sharded price data from the `asset_prices` collection.
- * This is a heavy operation and should be cached.
- */
-async function loadAllPriceData() {
-  const now = Date.now();
-  if (cache.timestamp && (now - cache.timestamp < CACHE_DURATION_MS)) {
-    return cache.priceMap;
-  }
-
-  if (fetchPromise) {
-    return fetchPromise;
-  }
-
-  fetchPromise = (async () => {
-    console.log('Fetching and caching all asset price data...');
-    const masterPriceMap = {};
-    
-    try {
-      const snapshot = await firestore.collection(PRICE_COLLECTION).get();
-      
-      if (snapshot.empty) {
-        throw new Error(`Price collection '${PRICE_COLLECTION}' is empty.`);
-      }
-
-      // Loop through each shard document (e.g., "shard_0", "shard_1")
-      snapshot.forEach(doc => {
-        const shardData = doc.data();
-        
-        // Loop through each instrumentId in the shard
-        for (const instrumentId in shardData) {
-          // Check if it's a valid instrument entry
-          if (shardData[instrumentId] && shardData[instrumentId].prices) {
-            masterPriceMap[instrumentId] = shardData[instrumentId].prices;
-          }
-        }
-      });
-
-      cache = {
-        timestamp: now,
-        priceMap: masterPriceMap,
-      };
-      
-      console.log(`Successfully cached prices for ${Object.keys(masterPriceMap).length} instruments.`);
-      return masterPriceMap;
-
-    } catch (err) {
-      console.error('CRITICAL: Error loading price data:', err);
-      // On error, return an empty map but don't cache, so a future call can retry.
-      return {};
-    } finally {
-      // Clear the promise so the next call (if cache is stale) triggers a new fetch
-      fetchPromise = null;
-    }
-  })();
-
-  return fetchPromise;
-}
-
-/**
- * A helper to safely get the price change percentage between two dates.
- * --- THIS IS THE MODIFIED FUNCTION ---
- * @param {string} instrumentId - The instrument ID.
- * @param {string} yesterdayStr - YYYY-MM-DD date string for yesterday.
- * @param {string} todayStr - YYYY-MM-DD date string for today.
- * @param {object} priceMap - The master price map from loadAllPriceData().
- * @returns {number|null} The percentage change (e.g., 0.10 for +10%), or null if data is missing.
- */
-function getDailyPriceChange(instrumentId, yesterdayStr, todayStr, priceMap) {
-    if (!priceMap || !priceMap[instrumentId]) {
-        return null; // No price data for this instrument
-    }
-    
-    const instrumentPrices = priceMap[instrumentId];
-
-    // Find the most recent available price *on or before* the target dates
-    const priceDay1 = _findPreviousAvailablePrice(instrumentPrices, yesterdayStr, 5);
-    const priceDay2 = _findPreviousAvailablePrice(instrumentPrices, todayStr, 5);
-
-    if (priceDay1 && priceDay2) {
-        // We found prices, now check if they are the *same* price
-        // (e.g., if today is Sunday, priceDay2 would be Friday's price.
-        // If yesterday was Saturday, priceDay1 would *also* be Friday's price).
-        if (priceDay1 === priceDay2) {
-            return 0.0; // No change between the two most recent *available* dates
-        }
-        return (priceDay2 - priceDay1) / priceDay1;
-    }
-    
-    return null; // Missing one or both dates, even after lookback
-}
-
-
-module.exports = {
-    loadAllPriceData,
-    getDailyPriceChange
-    // Add the helper to exports if you want, but it's not required
-};
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+
+// Config
+const PRICE_COLLECTION = 'asset_prices';
+const CACHE_DURATION_MS = 3600000; // 1 hour
+
+// Cache
+let cache = {
+  timestamp: null,
+  priceMap: null, // Will be { instrumentId: { "YYYY-MM-DD": price, ... } }
+};
+
+// In-progress fetch promise
+let fetchPromise = null;
+
+/**
+ * Finds the most recent available price on or before a given date.
+ * @param {object} priceHistory - The map of { "YYYY-MM-DD": price }
+ * @param {string} dateStr - The target date string to start searching from.
+ * @param {number} [maxLookback=5] - Max days to look back (to skip weekends/holidays).
+ * @returns {number|null} The price, or null if not found.
+ */
+function _findPreviousAvailablePrice(priceHistory, dateStr, maxLookback = 5) {
+    if (!priceHistory) return null;
+
+    let checkDate = new Date(dateStr + 'T00:00:00Z');
+    
+    for (let i = 0; i < maxLookback; i++) {
+        const checkDateStr = checkDate.toISOString().slice(0, 10);
+        const price = priceHistory[checkDateStr];
+        
+        if (price !== undefined && price !== null && price > 0) {
+            return price; // Found it
+        }
+        
+        // If not found, look back one more day
+        checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+    }
+    
+    // console.warn(`No price found for instrument within ${maxLookback} days of ${dateStr}`);
+    return null; // No price found within lookback
+}
+
+/**
+ * Loads all sharded price data from the `asset_prices` collection.
+ * This is a heavy operation and should be cached.
+ */
+async function loadAllPriceData() {
+  const now = Date.now();
+  if (cache.timestamp && (now - cache.timestamp < CACHE_DURATION_MS)) {
+    return cache.priceMap;
+  }
+
+  if (fetchPromise) {
+    return fetchPromise;
+  }
+
+  fetchPromise = (async () => {
+    console.log('Fetching and caching all asset price data...');
+    const masterPriceMap = {};
+    
+    try {
+      const snapshot = await firestore.collection(PRICE_COLLECTION).get();
+      
+      if (snapshot.empty) {
+        throw new Error(`Price collection '${PRICE_COLLECTION}' is empty.`);
+      }
+
+      // Loop through each shard document (e.g., "shard_0", "shard_1")
+      snapshot.forEach(doc => {
+        const shardData = doc.data();
+        
+        // Loop through each instrumentId in the shard
+        for (const instrumentId in shardData) {
+          // Check if it's a valid instrument entry
+          if (shardData[instrumentId] && shardData[instrumentId].prices) {
+            masterPriceMap[instrumentId] = shardData[instrumentId].prices;
+          }
+        }
+      });
+
+      cache = {
+        timestamp: now,
+        priceMap: masterPriceMap,
+      };
+      
+      console.log(`Successfully cached prices for ${Object.keys(masterPriceMap).length} instruments.`);
+      return masterPriceMap;
+
+    } catch (err) {
+      console.error('CRITICAL: Error loading price data:', err);
+      // On error, return an empty map but don't cache, so a future call can retry.
+      return {};
+    } finally {
+      // Clear the promise so the next call (if cache is stale) triggers a new fetch
+      fetchPromise = null;
+    }
+  })();
+
+  return fetchPromise;
+}
+
+/**
+ * A helper to safely get the price change percentage between two dates.
+ * --- THIS IS THE MODIFIED FUNCTION ---
+ * @param {string} instrumentId - The instrument ID.
+ * @param {string} yesterdayStr - YYYY-MM-DD date string for yesterday.
+ * @param {string} todayStr - YYYY-MM-DD date string for today.
+ * @param {object} priceMap - The master price map from loadAllPriceData().
+ * @returns {number|null} The percentage change (e.g., 0.10 for +10%), or null if data is missing.
+ */
+function getDailyPriceChange(instrumentId, yesterdayStr, todayStr, priceMap) {
+    if (!priceMap || !priceMap[instrumentId]) {
+        return null; // No price data for this instrument
+    }
+    
+    const instrumentPrices = priceMap[instrumentId];
+
+    // Find the most recent available price *on or before* the target dates
+    const priceDay1 = _findPreviousAvailablePrice(instrumentPrices, yesterdayStr, 5);
+    const priceDay2 = _findPreviousAvailablePrice(instrumentPrices, todayStr, 5);
+
+    if (priceDay1 && priceDay2) {
+        // We found prices, now check if they are the *same* price
+        // (e.g., if today is Sunday, priceDay2 would be Friday's price.
+        // If yesterday was Saturday, priceDay1 would *also* be Friday's price).
+        if (priceDay1 === priceDay2) {
+            return 0.0; // No change between the two most recent *available* dates
+        }
+        return (priceDay2 - priceDay1) / priceDay1;
+    }
+    
+    return null; // Missing one or both dates, even after lookback
+}
+
+
+module.exports = {
+    loadAllPriceData,
+    getDailyPriceChange
+    // Add the helper to exports if you want, but it's not required
+};

package/utils/sector_mapping_provider.js

@@ -1,75 +1,75 @@
-const { Firestore } = require('@google-cloud/firestore');
-const firestore = new Firestore();
-
-let cache = {
-  timestamp: null,
-  instrumentToSector: null,
-  instrumentToTicker: null,
-};
-
-// This variable will hold the promise for the in-progress fetch operation.
-let fetchPromise = null;
-
-async function loadInstrumentMappings() {
-  const now = Date.now();
-  // If the cache is recent, return it immediately.
-  if (cache.timestamp && (now - cache.timestamp < 3600000)) {
-    return cache;
-  }
-
-  // If a fetch is not already in progress, start one.
-  if (!fetchPromise) {
-    fetchPromise = (async () => {
-      try {
-        console.log('Fetching instrument mappings...');
-        const [tickerToIdDoc, tickerToSectorDoc] = await Promise.all([
-          firestore.collection('instrument_mappings').doc('etoro_to_ticker').get(),
-          firestore.collection('instrument_sector_mappings').doc('sector_mappings').get()
-        ]);
-
-        if (!tickerToIdDoc.exists || !tickerToSectorDoc.exists) {
-          throw new Error('Instrument mapping documents missing.');
-        }
-
-        const tickerToId = tickerToIdDoc.data();
-        const tickerToSector = tickerToSectorDoc.data();
-
-        const idToTicker = Object.fromEntries(Object.entries(tickerToId).map(([id, ticker]) => [id, ticker]));
-
-        const idToSector = Object.fromEntries(
-          Object.entries(idToTicker).map(([id, ticker]) => [id, tickerToSector[ticker] || 'N/A'])
-        );
-
-        // Update the cache with the new data.
-        cache = {
-          timestamp: now,
-          instrumentToTicker: idToTicker,
-          instrumentToSector: idToSector,
-        };
-
-        console.log('Mappings cached successfully.');
-        return cache;
-
-      } catch (err) {
-        console.error('Error loading instrument mappings:', err);
-        // On error, don't cache, so a future call can retry.
-        return { instrumentToTicker: {}, instrumentToSector: {} };
-      } finally {
-        // IMPORTANT: Reset the promise so that if the cache expires,
-        // a new fetch can be initiated later.
-        fetchPromise = null;
-      }
-    })();
-  }
-
-  // Return the promise for the in-progress fetch.
-  // Subsequent calls will wait for this single promise to resolve.
-  return fetchPromise;
-}
-
-async function getInstrumentSectorMap() {
-  const mappings = await loadInstrumentMappings();
-  return mappings.instrumentToSector;
-}
-
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+
+let cache = {
+  timestamp: null,
+  instrumentToSector: null,
+  instrumentToTicker: null,
+};
+
+// This variable will hold the promise for the in-progress fetch operation.
+let fetchPromise = null;
+
+async function loadInstrumentMappings() {
+  const now = Date.now();
+  // If the cache is recent, return it immediately.
+  if (cache.timestamp && (now - cache.timestamp < 3600000)) {
+    return cache;
+  }
+
+  // If a fetch is not already in progress, start one.
+  if (!fetchPromise) {
+    fetchPromise = (async () => {
+      try {
+        console.log('Fetching instrument mappings...');
+        const [tickerToIdDoc, tickerToSectorDoc] = await Promise.all([
+          firestore.collection('instrument_mappings').doc('etoro_to_ticker').get(),
+          firestore.collection('instrument_sector_mappings').doc('sector_mappings').get()
+        ]);
+
+        if (!tickerToIdDoc.exists || !tickerToSectorDoc.exists) {
+          throw new Error('Instrument mapping documents missing.');
+        }
+
+        const tickerToId = tickerToIdDoc.data();
+        const tickerToSector = tickerToSectorDoc.data();
+
+        const idToTicker = Object.fromEntries(Object.entries(tickerToId).map(([id, ticker]) => [id, ticker]));
+
+        const idToSector = Object.fromEntries(
+          Object.entries(idToTicker).map(([id, ticker]) => [id, tickerToSector[ticker] || 'N/A'])
+        );
+
+        // Update the cache with the new data.
+        cache = {
+          timestamp: now,
+          instrumentToTicker: idToTicker,
+          instrumentToSector: idToSector,
+        };
+
+        console.log('Mappings cached successfully.');
+        return cache;
+
+      } catch (err) {
+        console.error('Error loading instrument mappings:', err);
+        // On error, don't cache, so a future call can retry.
+        return { instrumentToTicker: {}, instrumentToSector: {} };
+      } finally {
+        // IMPORTANT: Reset the promise so that if the cache expires,
+        // a new fetch can be initiated later.
+        fetchPromise = null;
+      }
+    })();
+  }
+
+  // Return the promise for the in-progress fetch.
+  // Subsequent calls will wait for this single promise to resolve.
+  return fetchPromise;
+}
+
+async function getInstrumentSectorMap() {
+  const mappings = await loadInstrumentMappings();
+  return mappings.instrumentToSector;
+}
+
 module.exports = { loadInstrumentMappings, getInstrumentSectorMap };

package/calculations/capital_flow/historical/reallocation_increase_percentage.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Calculates the average percentage increase in allocation
- * specifically towards assets already held on the previous day.
- */
-
-class ReallocationIncreasePercentage {
-    constructor() {
-        this.accumulatedIncreasePercentage = 0;
-        this.userCount = 0;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
-            // Requires AggregatedPositions which contain the 'Invested' percentage
-            return;
-        }
-
-        const yesterdayPositions = new Map(yesterdayPortfolio.AggregatedPositions.map(p => [p.InstrumentID, p]));
-        let userTotalIncreasePercentage = 0;
-
-        for (const todayPos of todayPortfolio.AggregatedPositions) {
-            const yesterdayPos = yesterdayPositions.get(todayPos.InstrumentID);
-
-            // Check if the asset was held yesterday
-            if (yesterdayPos) {
-                // Ensure 'Invested' property exists and is a number
-                const todayInvested = typeof todayPos.Invested === 'number' ? todayPos.Invested : 0;
-                const yesterdayInvested = typeof yesterdayPos.Invested === 'number' ? yesterdayPos.Invested : 0;
-
-                const deltaInvested = todayInvested - yesterdayInvested;
-
-                // Accumulate only the increases
-                if (deltaInvested > 0) {
-                    userTotalIncreasePercentage += deltaInvested;
-                }
-            }
-        }
-
-        // Only count users who had positions on both days for this metric
-        if (yesterdayPortfolio.AggregatedPositions.length > 0 && todayPortfolio.AggregatedPositions.length > 0) {
-           this.accumulatedIncreasePercentage += userTotalIncreasePercentage;
-           this.userCount++;
-        }
-    }
-
-    getResult() {
-        if (this.userCount === 0) {
-            return {};
-        }
-
-        return {
-             // Calculate the final average directly
-            average_reallocation_increase_percentage: this.accumulatedIncreasePercentage / this.userCount
-        };
-    }
-
-    reset() {
-        this.accumulatedIncreasePercentage = 0;
-        this.userCount = 0;
-    }
-}
-
-module.exports = ReallocationIncreasePercentage;

package/calculations/speculators/stop_loss_distance_by_sector_short_long_breakdown.js

@@ -1,91 +0,0 @@
-/**
- * @fileoverview Calculates the average stop loss distance (percent and value)
- * for long and short positions, grouped by SECTOR.
- */
-const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
-
-class StopLossDistanceBySector {
-    constructor() {
-        this.instrumentData = {};
-        this.instrumentToSector = null;
-    }
-
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (!portfolioData || !portfolioData.PublicPositions) return;
-
-        for (const position of portfolioData.PublicPositions) {
-            const { InstrumentID, Leverage, StopLossRate, CurrentRate, IsBuy } = position;
-            if (Leverage <= 1 || StopLossRate <= 0.0001 || CurrentRate <= 0) continue;
-
-            const distance_value = IsBuy ? CurrentRate - StopLossRate : StopLossRate - CurrentRate;
-            const distance_percent = (distance_value / CurrentRate) * 100;
-
-            if (distance_percent > 0) {
-                const posType = IsBuy ? 'long' : 'short';
-                if (!this.instrumentData[InstrumentID]) this.instrumentData[InstrumentID] = {};
-                if (!this.instrumentData[InstrumentID][posType]) {
-                    this.instrumentData[InstrumentID][posType] = {
-                        distance_percent_sum: 0,
-                        distance_value_sum: 0,
-                        count: 0
-                    };
-                }
-                const agg = this.instrumentData[InstrumentID][posType];
-                agg.distance_percent_sum += distance_percent;
-                agg.distance_value_sum += distance_value;
-                agg.count++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (Object.keys(this.instrumentData).length === 0) return {};
-        if (!this.instrumentToSector) {
-            this.instrumentToSector = await getInstrumentSectorMap();
-        }
-
-        const sectorData = {};
-        for (const instrumentId in this.instrumentData) {
-            const sector = this.instrumentToSector[instrumentId] || 'N/A';
-            if (!sectorData[sector]) sectorData[sector] = {};
-
-            for (const posType in this.instrumentData[instrumentId]) {
-                if (!sectorData[sector][posType]) {
-                    sectorData[sector][posType] = {
-                        distance_percent_sum: 0,
-                        distance_value_sum: 0,
-                        count: 0
-                    };
-                }
-                const source = this.instrumentData[instrumentId][posType];
-                const target = sectorData[sector][posType];
-                target.distance_percent_sum += source.distance_percent_sum;
-                target.distance_value_sum += source.distance_value_sum;
-                target.count += source.count;
-            }
-        }
-
-        const result = {};
-        for (const sector in sectorData) {
-            result[sector] = {};
-            for (const posType in sectorData[sector]) {
-                const data = sectorData[sector][posType];
-                // REFACTOR: Perform final calculation and return in standardized format.
-                if (data.count > 0) {
-                    result[sector][posType] = {
-                        average_distance_percent: data.distance_percent_sum / data.count,
-                        average_distance_value: data.distance_value_sum / data.count,
-                        count: data.count
-                    };
-                }
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.instrumentData = {};
-    }
-}
-
-module.exports = StopLossDistanceBySector;

package/calculations/speculators/stop_loss_distance_by_ticker_short_long_breakdown.js

@@ -1,73 +0,0 @@
-/**
- * @fileoverview Calculates the average stop loss distance (percent and value)
- * for long and short positions, grouped by TICKER.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class StopLossDistanceByTicker {
-    constructor() {
-        this.instrumentData = {};
-        this.instrumentToTicker = null;
-    }
-
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (!portfolioData || !portfolioData.PublicPositions) return;
-
-        for (const position of portfolioData.PublicPositions) {
-            const { InstrumentID, Leverage, StopLossRate, CurrentRate, IsBuy } = position;
-            if (Leverage <= 1 || StopLossRate <= 0.0001 || CurrentRate <= 0) continue;
-
-            const distance_value = IsBuy ? CurrentRate - StopLossRate : StopLossRate - CurrentRate;
-            const distance_percent = (distance_value / CurrentRate) * 100;
-
-            if (distance_percent > 0) {
-                const posType = IsBuy ? 'long' : 'short';
-                if (!this.instrumentData[InstrumentID]) this.instrumentData[InstrumentID] = {};
-                if (!this.instrumentData[InstrumentID][posType]) {
-                    this.instrumentData[InstrumentID][posType] = {
-                        distance_percent_sum: 0,
-                        distance_value_sum: 0,
-                        count: 0
-                    };
-                }
-                const agg = this.instrumentData[InstrumentID][posType];
-                agg.distance_percent_sum += distance_percent;
-                agg.distance_value_sum += distance_value;
-                agg.count++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (Object.keys(this.instrumentData).length === 0) return {};
-        if (!this.instrumentToTicker) {
-            const mappings = await loadInstrumentMappings();
-            this.instrumentToTicker = mappings.instrumentToTicker;
-        }
-
-        const result = {};
-        for (const instrumentId in this.instrumentData) {
-            const ticker = this.instrumentToTicker[instrumentId] || `unknown_${instrumentId}`;
-            if (!result[ticker]) result[ticker] = {};
-
-            for (const posType in this.instrumentData[instrumentId]) {
-                const data = this.instrumentData[instrumentId][posType];
-                // REFACTOR: Perform final calculation and return in standardized format.
-                if (data.count > 0) {
-                    result[ticker][posType] = {
-                        average_distance_percent: data.distance_percent_sum / data.count,
-                        average_distance_value: data.distance_value_sum / data.count,
-                        count: data.count
-                    };
-                }
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.instrumentData = {};
-    }
-}
-
-module.exports = StopLossDistanceByTicker;