aiden-shared-calculations-unified 1.0.86 → 1.0.88

package/calculations/core/platform-daily-bought-vs-sold-count.js

@@ -1,148 +1,92 @@
 /**
- * @fileoverview Calculation (Pass 2) for daily bought vs. sold count.
- *
- * This metric tracks the total number of positions 'bought' (new)
- * and 'sold' (closed) today, based on daily ownership change.
- *
- * This is different from 'daily_asset_activity' because it counts
- * *positions*, not *unique users*.
+ * @fileoverview Calculation (Pass 1) for daily bought vs. sold count.
+ * REFACTORED: Uses context.math.extract on today vs yesterday.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class DailyBoughtVsSoldCount {
     constructor() {
-        // We will store { [instrumentId]: { new: 0, closed: 0 } }
         this.assetActivity = new Map();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: true, // Needs yesterday's portfolio
+            isHistorical: true,
             userType: 'all',
             category: 'core_metrics'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
-            "description": "Daily trade activity for a specific asset.",
             "properties": {
-                "positions_bought": {
-                    "type": "number",
-                    "description": "Total new positions opened for this asset."
-                },
-                "positions_sold": {
-                    "type": "number",
-                    "description": "Total positions closed for this asset."
-                },
-                "net_change": {
-                    "type": "number",
-                    "description": "Net change in positions (bought - sold)."
-                }
+                "positions_bought": { "type": "number" },
+                "positions_sold": { "type": "number" },
+                "net_change": { "type": "number" }
             },
             "required": ["positions_bought", "positions_sold", "net_change"]
         };
-
-        return {
-            "type": "object",
-            "description": "Tracks new positions (bought) and closed positions (sold) per asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Matches any string key (ticker)
-            },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instrumentId) {
         if (!this.assetActivity.has(instrumentId)) {
-            this.assetActivity.set(instrumentId, {
-                new: 0,
-                closed: 0
-            });
+            this.assetActivity.set(instrumentId, { new: 0, closed: 0 });
         }
     }
 
-    _getInstrumentIds(portfolio) {
-        // This MUST use PositionID to be accurate
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
+    _getInstrumentIds(positions, extract) {
+        const map = new Map();
+        for (const pos of positions) {
+            const posId = extract.getPositionId(pos);
+            const instId = extract.getInstrumentId(pos);
+            if (posId && instId) map.set(posId, instId);
         }
-        // Map<PositionID, InstrumentID>
-        return new Map(positions.map(p => [p.PositionID, p.InstrumentID]).filter(p => p[0] && p[1]));
+        return map;
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE (added context) ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
+        const todayPositions = extract.getPositions(user.portfolio.today, user.type);
+        const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
 
-        const yPosMap = this._getInstrumentIds(yesterdayPortfolio); // Map<PosID, InstID>
-        const tPosMap = this._getInstrumentIds(todayPortfolio); // Map<PosID, InstID>
+        const tPosMap = this._getInstrumentIds(todayPositions, extract);
+        const yPosMap = this._getInstrumentIds(yesterdayPositions, extract);
 
-        // Find new positions (in today but not yesterday)
-        for (const [tPosId, tInstId] of tPosMap.entries()) {
-            if (!yPosMap.has(tPosId)) {
-                this._initAsset(tInstId);
-                this.assetActivity.get(tInstId).new++;
+        // New positions (in today, not yesterday)
+        for (const [posId, instId] of tPosMap.entries()) {
+            if (!yPosMap.has(posId)) {
+                this._initAsset(instId);
+                this.assetActivity.get(instId).new++;
             }
         }
 
-        // Find closed positions (in yesterday but not today)
-        for (const [yPosId, yInstId] of yPosMap.entries()) {
-            if (!tPosMap.has(yPosId)) {
-                this._initAsset(yInstId);
-                this.assetActivity.get(yInstId).closed++;
+        // Closed positions (in yesterday, not today)
+        for (const [posId, instId] of yPosMap.entries()) {
+            if (!tPosMap.has(posId)) {
+                this._initAsset(instId);
+                this.assetActivity.get(instId).closed++;
             }
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
-        }
-
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, data] of this.assetActivity.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            
-            const openCount = data.new;
-            const closeCount = data.closed;
-            
-            if (openCount > 0 || closeCount > 0) {
+        for (const [instId, data] of this.assetActivity.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            if (data.new > 0 || data.closed > 0) {
                 result[ticker] = {
-                    positions_bought: openCount,
-                    positions_sold: closeCount,
-                    net_change: openCount - closeCount 
+                    positions_bought: data.new,
+                    positions_sold: data.closed,
+                    net_change: data.new - data.closed
                 };
             }
         }
@@ -151,9 +95,7 @@ class DailyBoughtVsSoldCount {
 
     reset() {
         this.assetActivity.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 }
-
 module.exports = DailyBoughtVsSoldCount;

package/calculations/core/platform-daily-ownership-delta.js

@@ -1,161 +1,103 @@
 /**
- * @fileoverview Calculation (Pass 1) for daily ownership delta.
- *
- * This metric calculates the daily change in the total number of *owners*
- * (unique users) for each instrument.
- *
- * REFACTOR: This is now a 'type: "meta"' and 'isHistorical: true' calculation.
- * It runs ONCE, loads today's and yesterday's pre-aggregated 'insights' docs,
- * and calculates the delta based on the 'total' field.
+ * @fileoverview Calculation (Pass 1) for ownership delta (users added/lost per asset).
+ * REFACTORED: Tracks net change in number of owners. ---> TODO IN TEST ENVIRONMENT THE VALUE OF NUMBER OF CLOSURES ALWAYS RETURNS 0, IS THIS A COMPUTATION BUG OR A TEST HARNESS BUG?
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
-class DailyOwnershipDelta {
-    
-    // --- STANDARD 2: ADDED ---
+class PlatformDailyOwnershipDelta {
     constructor() {
-        this.result = {};
+        this.assetChanges = new Map(); // { instId: { added: 0, removed: 0 } }
+        this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
-            type: 'meta',
-            rootDataDependencies: ['insights'], // Needs insights doc
-            isHistorical: true, // Needs yesterday's insights doc
-            userType: 'n/a',
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: true,
+            userType: 'all',
             category: 'core_metrics'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
-            "description": "Daily change in unique owners for a specific asset.",
             "properties": {
-                "owners_today": {
-                    "type": "number",
-                    "description": "Total unique users holding this asset today."
-                },
-                "owners_yesterday": {
-                    "type": "number",
-                    "description": "Total unique users holding this asset yesterday."
-                },
-                "owner_delta": {
-                    "type": "number",
-                    "description": "The net change in unique owners (today - yesterday)."
-                },
-                "owner_delta_percent": {
-                    "type": ["number", "null"],
-                    "description": "Percentage change in unique owners. Null if yesterday had 0 owners."
-                }
+                "owners_added": { "type": "number" },
+                "owners_removed": { "type": "number" },
+                "net_ownership_change": { "type": "number" }
             },
-            "required": ["owners_today", "owners_yesterday", "owner_delta", "owner_delta_percent"]
+            "required": ["owners_added", "owners_removed", "net_ownership_change"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
 
-        return {
-            "type": "object",
-            "description": "Calculates the daily change in the total number of unique owners for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Matches any string key (ticker)
-            },
-            "additionalProperties": tickerSchema
-        };
+    _initAsset(instId) {
+        if (!this.assetChanges.has(instId)) {
+            this.assetChanges.set(instId, { added: 0, removed: 0 });
+        }
+    }
+
+    _getOwnedInstruments(positions, extract) {
+        const set = new Set();
+        for (const pos of positions) {
+            const id = extract.getInstrumentId(pos);
+            if (id) set.add(id);
+        }
+        return set;
     }
 
-    /**
-     * This is a 'meta' and 'historical' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        
-        // ---
-        // FIX: The test harness ('worker.js') is now our "ground truth".
-        //
-        // 1. Get Ticker Mappings:
-        //    'worker.js' passes the context object as ARGUMENT 4 (named 'config').
-        //    This context *already contains* the ticker map.
-        // ---
-        const { instrumentToTicker } = config; // 'config' is Param 4
-        
-        const todayOwners = new Map();
-        const yesterdayOwners = new Map();
-        const allInstrumentIds = new Set();
-        
-        // ---
-        // 2. Get Data:
-        //    'worker.js' passes the root data object as ARGUMENT 1 (named 'dateStr').
-        // ---
-        const rootDataToday = dateStr; // 'dateStr' is Param 1
-        
-        const todayDoc = rootDataToday?.insights;
-        const yesterdayDoc = rootDataToday?.yesterdayInsights;
-        
-        // 1. Process today's insights doc
-        if (todayDoc && Array.isArray(todayDoc.insights)) {
-            for (const instrument of todayDoc.insights) {
-                const id = instrument.instrumentId;
-                const totalOwners = instrument.total || 0; // 'total' is the owner count
-                todayOwners.set(id, totalOwners);
-                allInstrumentIds.add(id);
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+
+        // If either portfolio is missing, we can't calculate delta for this user
+        if (!user.portfolio.today || !user.portfolio.yesterday) return;
+
+        const todayPositions = extract.getPositions(user.portfolio.today, user.type);
+        const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
+
+        const tSet = this._getOwnedInstruments(todayPositions, extract);
+        const ySet = this._getOwnedInstruments(yesterdayPositions, extract);
+
+        // Added: In Today, Not Yesterday
+        for (const instId of tSet) {
+            if (!ySet.has(instId)) {
+                this._initAsset(instId);
+                this.assetChanges.get(instId).added++;
             }
         }
-        
-        // 2. Process yesterday's insights doc
-        if (yesterdayDoc && Array.isArray(yesterdayDoc.insights)) {
-            for (const instrument of yesterdayDoc.insights) {
-                const id = instrument.instrumentId;
-                const totalOwners = instrument.total || 0; // 'total' is the owner count
-                yesterdayOwners.set(id, totalOwners);
-                allInstrumentIds.add(id);
+
+        // Removed: In Yesterday, Not Today
+        for (const instId of ySet) {
+            if (!tSet.has(instId)) {
+                this._initAsset(instId);
+                this.assetChanges.get(instId).removed++;
             }
         }
-        
-        // 3. Calculate deltas
+    }
+
+    async getResult() {
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const instrumentId of allInstrumentIds) {
-            // --- Use the map from Param 4 ---
-            const ticker = instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            
-            const tOwners = todayOwners.get(instrumentId) || 0;
-            const yOwners = yesterdayOwners.get(instrumentId) || 0;
-            
-            if (yOwners > 0 || tOwners > 0) {
+        for (const [instId, data] of this.assetChanges.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            if (data.added > 0 || data.removed > 0) {
                 result[ticker] = {
-                    owners_today: tOwners,
-                    owners_yesterday: yOwners,
-                    owner_delta: tOwners - yOwners,
-                    owner_delta_percent: (yOwners > 0) ? ((tOwners - yOwners) / yOwners) * 100 : null
+                    owners_added: data.added,
+                    owners_removed: data.removed,
+                    net_ownership_change: data.added - data.removed
                 };
             }
         }
-        
-        // --- STANDARD 2: SET STATE, DO NOT RETURN ---
-        this.result = result;
+        return result;
     }
 
-    // --- STANDARD 2: ADDED ---
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
-
-    // --- STANDARD 2: ADDED ---
     reset() {
-        this.result = {};
+        this.assetChanges.clear();
+        this.tickerMap = null;
     }
 }
-
-module.exports = DailyOwnershipDelta;
+module.exports = PlatformDailyOwnershipDelta;

package/calculations/core/platform-ownership-per-sector.js

@@ -1,129 +1,78 @@
 /**
- * @fileoverview Calculation (Pass 1) for daily ownership per sector.
- *
- * This is a 'type: "meta"' calculation. It runs ONCE.
- * It reads the pre-aggregated 'insights' data source (/daily_instrument_insights/)
- * and uses the sector mapping provider to aggregate the total number
- * of owners for each sector.
+ * @fileoverview Calculation (Pass 1) for sector ownership.
+ * REFACTORED: Uses exposure weight.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-class DailyOwnershipPerSector {
-
-    // --- STANDARD 2: ADDED ---
+class PlatformOwnershipPerSector {
     constructor() {
-        this.result = {};
+        this.sectorData = new Map();
+        this.sectorMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
-            type: 'meta',
-            rootDataDependencies: ['insights'], // Needs insights doc
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'n/a',
-            category: 'core_metrics'
+            userType: 'all',
+            category: 'core'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        const sectorSchema = {
+        const schema = {
             "type": "object",
-            "description": "Aggregated ownership for a single sector.",
             "properties": {
-                "total_owners": {
-                    "type": "number",
-                    "description": "The total number of unique owners for all assets in this sector."
-                }
+                "total_exposure_weight": { "type": "number" },
+                "position_count": { "type": "number" }
             },
-            "required": ["total_owners"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the total unique owners per sector based on the 'insights' data source.",
-            "patternProperties": {
-                "^.*$": sectorSchema // Matches any string key (sector name)
-            },
-            "additionalProperties": sectorSchema
+            "required": ["total_exposure_weight", "position_count"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        // { [sectorName]: { total_owners: 0 } }
-        const sectorOwners = new Map();
-        
-        // ---
-        // FIX: The test harness ('worker.js') is our "ground truth".
-        //
-        // 1. Get Logger & Mappings:
-        //    'worker.js' passes the context object as ARGUMENT 4 (named 'config').
-        //    This context *already contains* the sector map.
-        // ---
-        const { logger, sectorMapping } = config; // 'config' is Param 4
-
-        // 2. Get the insights document
-        //    'worker.js' passes the root data object as ARGUMENT 1 (named 'dateStr').
-        // ---
-        const rootDataToday = dateStr; // 'dateStr' is Param 1
-        const insightsDoc = rootDataToday.insights;
-        
-        if (!insightsDoc || !Array.isArray(insightsDoc.insights)) {
-            logger.log('WARN', `[daily-ownership-per-sector] No 'insights' data found.`);
-            this.result = {};
-            return;
+    _initSector(sector) {
+        if (!this.sectorData.has(sector)) {
+            this.sectorData.set(sector, { weight: 0, count: 0 });
         }
+    }
 
-        // 3. Iterate over the pre-aggregated array
-        for (const instrument of insightsDoc.insights) {
-            const instrumentId = instrument.instrumentId;
-            const totalOwners = instrument.total; // 'total' is the owner count
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.sectorMap) this.sectorMap = mappings.sectorMapping;
 
-            if (!instrumentId || typeof totalOwners !== 'number' || totalOwners === 0) {
-                continue;
-            }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
-            // --- Use the map from Param 4 ---
-            const sectorName = sectorMapping[instrumentId] || 'N/A';
+        for (const pos of positions) {
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-            // Initialize if new
-            if (!sectorOwners.has(sectorName)) {
-                sectorOwners.set(sectorName, { total_owners: 0 });
-            }
+            const sector = this.sectorMap[instId] || 'Unknown';
+            const weight = extract.getPositionWeight(pos, user.type);
 
-            // Add this instrument's owners to the sector's total
-            sectorOwners.get(sectorName).total_owners += totalOwners;
+            this._initSector(sector);
+            const data = this.sectorData.get(sector);
+            data.weight += weight;
+            data.count++;
         }
-
-        // --- STANDARD 2: SET STATE, DO NOT RETURN ---
-        this.result = Object.fromEntries(sectorOwners);
     }
 
-    // --- STANDARD 2: ADDED ---
-    async getResult(fetchedDependencies) {
-        return this.result;
+    async getResult() {
+        const result = {};
+        for (const [sector, data] of this.sectorData.entries()) {
+            result[sector] = {
+                total_exposure_weight: data.weight,
+                position_count: data.count
+            };
+        }
+        return result;
     }
 
-    // --- STANDARD 2: ADDED ---
     reset() {
-        this.result = {};
+        this.sectorData.clear();
+        this.sectorMap = null;
     }
 }
-
-module.exports = DailyOwnershipPerSector;
+module.exports = PlatformOwnershipPerSector;