bulltrackers-module 1.0.182 → 1.0.184

package/functions/computation-system/controllers/computation_controller.js

@@ -1,6 +1,6 @@
 /**
  * FIXED: computation_controller.js
- * V3.2: Supports Streaming Trading History (todayHistory) separate from Yesterday's Portfolio.
+ * V3.4: Adds Price Loading & Context Injection.
  */
 
 const { DataExtractor, 
@@ -23,7 +23,7 @@ class DataLoader {
     constructor(config, dependencies) {
         this.config = config;
         this.deps = dependencies;
-        this.cache = { mappings: null, insights: new Map(), social: new Map() };
+        this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null };
     }
     async loadMappings() {
         if (this.cache.mappings) return this.cache.mappings;
@@ -43,6 +43,39 @@ class DataLoader {
         this.cache.social.set(dateStr, social);
         return social;
     }
+    /**
+     * NEW: Loads sharded price data for Meta calculations
+     */
+    async loadPrices() {
+        if (this.cache.prices) return this.cache.prices;
+        const { db, logger } = this.deps;
+        const collection = this.config.priceCollection || 'asset_prices';
+        
+        logger.log('INFO', `[DataLoader] Loading all price shards from ${collection}...`);
+        
+        try {
+            const snapshot = await db.collection(collection).get();
+            if (snapshot.empty) return { history: {} };
+
+            const historyMap = {};
+            
+            snapshot.forEach(doc => {
+                const shardData = doc.data();
+                // Merge shard keys (instrumentIds) into main map
+                if (shardData) Object.assign(historyMap, shardData);
+            });
+
+            logger.log('INFO', `[DataLoader] Loaded prices for ${Object.keys(historyMap).length} instruments.`);
+            
+            // Cache as an object with 'history' map to match priceExtractor expectations
+            this.cache.prices = { history: historyMap };
+            return this.cache.prices;
+
+        } catch (e) {
+            logger.log('ERROR', `[DataLoader] Failed to load prices: ${e.message}`);
+            return { history: {} };
+        }
+    }
 }
 
 class ContextBuilder {
@@ -76,7 +109,7 @@ class ContextBuilder {
             insights: { today: insights?.today, yesterday: insights?.yesterday },
             social: { today: socialData?.today, yesterday: socialData?.yesterday },
             mappings: mappings || {},
-            math: { // Introduced a new computation class in the math primitives? Add it here. Then add it to meta context a little further down.
+            math: { 
                 extract: DataExtractor,
                 history: HistoryExtractor,
                 compute: MathPrimitives,
@@ -103,6 +136,7 @@ class ContextBuilder {
             mappings, 
             insights, 
             socialData,
+            prices, // <--- ADDED THIS
             computedDependencies, 
             previousComputedDependencies,
             config, 
@@ -113,8 +147,9 @@ class ContextBuilder {
             date: { today: dateStr },
             insights: { today: insights?.today, yesterday: insights?.yesterday },
             social: { today: socialData?.today, yesterday: socialData?.yesterday },
+            prices: prices || {}, // <--- INJECTED HERE
             mappings: mappings || {},
-            math: { // Introduced a new computation class in the math primitives? Add it here.
+            math: { 
                 extract: DataExtractor,
                 history: HistoryExtractor,
                 compute: MathPrimitives,
@@ -142,22 +177,22 @@ class ComputationExecutor {
         this.loader = dataLoader;
     }
 
-    /**
-     * UPDATED: Accepts yesterdayPortfolioData AND historyData separately.
-     */
     async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps) {
         const { logger } = this.deps;
         const targetUserType = metadata.userType; 
         const mappings = await this.loader.loadMappings();
         const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        
         for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
             const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
             const todayHistory = historyData ? historyData[userId] : null;
             const actualUserType = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
+            
             if (targetUserType !== 'all') {
                  const mappedTarget = (targetUserType === 'speculator') ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
                  if (mappedTarget !== actualUserType) continue;
             }
+            
             const context = ContextBuilder.buildPerUserContext({
                 todayPortfolio, yesterdayPortfolio,
                 todayHistory, 
@@ -166,6 +201,7 @@ class ComputationExecutor {
                 previousComputedDependencies: prevDeps,
                 config: this.config, deps: this.deps
             });
+            
             try { await calcInstance.process(context); } 
             catch (e) { logger.log('WARN', `Calc ${metadata.name} failed for user ${userId}: ${e.message}`); }
         }
@@ -173,10 +209,20 @@ class ComputationExecutor {
 
     async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps) {
         const mappings = await this.loader.loadMappings();
+        
+        // Load standard dependencies
         const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
         const social = metadata.rootDataDependencies?.includes('social') ? { today: await this.loader.loadSocial(dateStr) } : null;
+        
+        // NEW: Load Price dependencies if required
+        let prices = null;
+        if (metadata.rootDataDependencies?.includes('price')) {
+            prices = await this.loader.loadPrices();
+        }
+
         const context = ContextBuilder.buildMetaContext({
             dateStr, metadata, mappings, insights, socialData: social,
+            prices, // Pass prices to builder
             computedDependencies: computedDeps,
             previousComputedDependencies: prevDeps,
             config: this.config, deps: this.deps

package/functions/computation-system/helpers/computation_pass_runner.js

@@ -7,7 +7,7 @@ const {
     checkRootDataAvailability, 
     fetchExistingResults, 
     fetchComputationStatus,   
-    updateComputationStatus,  
+    updateComputationStatus,
     runStandardComputationPass, 
     runMetaComputationPass,
     checkRootDependencies
@@ -36,7 +36,7 @@ async function runComputationPass(config, dependencies, computationManifest) {
         return logger.log('WARN', `[PassRunner] No calcs for Pass ${passToRun}. Exiting.`);
     
     const passEarliestDate = earliestDates.absoluteEarliest; 
-    const endDateUTC = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
+    const endDateUTC       = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
     const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
 
     const standardCalcs = calcsInThisPass.filter(c => c.type === 'standard');

package/functions/computation-system/helpers/orchestration_helpers.js

@@ -1,5 +1,6 @@
 /**
  * FILENAME: bulltrackers-module/functions/computation-system/helpers/orchestration_helpers.js
+ * FIXED: Explicit Logging + Honest Status Updates
  */
 
 const { ComputationController }              = require('../controllers/computation_controller');
@@ -35,7 +36,6 @@ function checkRootDependencies(calcManifest, rootDataStatus) {
  * Checks for the availability of all required root data for a specific date.
  */
 async function checkRootDataAvailability(dateStr, config, dependencies, earliestDates) {
-    // ... [Unchanged content of checkRootDataAvailability] ...
     const { logger }    = dependencies;
     const dateToProcess = new Date(dateStr + 'T00:00:00Z');
     let portfolioRefs   = [],    historyRefs = [];
@@ -64,10 +64,6 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
     }
 }
 
-/**
- * --- DEPRECATED: Old per-date fetch ---
- * Keeps compatibility but logic moves to fetchGlobalComputationStatus
- */
 async function fetchComputationStatus(dateStr, config, { db }) {
     const collection = config.computationStatusCollection || 'computation_status';
     const docRef     = db.collection(collection).doc(dateStr);
@@ -75,10 +71,6 @@ async function fetchComputationStatus(dateStr, config, { db }) {
     return snap.exists ? snap.data() : {};
 }
 
-/**
- * --- NEW: Fetches the SINGLE GLOBAL status document ---
- * Loads the entire history of statuses in one read.
- */
 async function fetchGlobalComputationStatus(config, { db }) {
     const collection = config.computationStatusCollection || 'computation_status';
     const docRef = db.collection(collection).doc('global_status');
@@ -86,9 +78,6 @@ async function fetchGlobalComputationStatus(config, { db }) {
     return snap.exists ? snap.data() : {};
 }
 
-/**
- * --- DEPRECATED: Old per-date update ---
- */
 async function updateComputationStatus(dateStr, updates, config, { db }) {
     if (!updates || Object.keys(updates).length === 0) return;
     const collection = config.computationStatusCollection || 'computation_status';
@@ -96,17 +85,11 @@ async function updateComputationStatus(dateStr, updates, config, { db }) {
     await docRef.set(updates, { merge: true }); 
 }
 
-/**
- * --- NEW: Batch Updates to Global Document ---
- * Accepts a map of { "YYYY-MM-DD": { calcName: true, ... } }
- * and writes them using dot notation to avoid overwriting other dates.
- */
 async function updateGlobalComputationStatus(updatesByDate, config, { db }) {
     if (!updatesByDate || Object.keys(updatesByDate).length === 0) return;
     const collection = config.computationStatusCollection || 'computation_status';
     const docRef = db.collection(collection).doc('global_status');
     
-    // Flatten to dot notation for Firestore update: "2023-10-27.calcName": true
     const flattenUpdates = {};
     for (const [date, statuses] of Object.entries(updatesByDate)) {
         for (const [calc, status] of Object.entries(statuses)) {
@@ -117,7 +100,6 @@ async function updateGlobalComputationStatus(updatesByDate, config, { db }) {
     try {
         await docRef.update(flattenUpdates);
     } catch (err) {
-        // If doc doesn't exist (first run), update fails. Use set({merge:true}).
         if (err.code === 5) { // NOT_FOUND
              const deepObj = {};
              for (const [date, statuses] of Object.entries(updatesByDate)) {
@@ -130,10 +112,6 @@ async function updateGlobalComputationStatus(updatesByDate, config, { db }) {
     }
 }
 
-/**
- * --- UPDATED: fetchExistingResults ---
- * (Unchanged, keeps fetching results per date as this is heavy data)
- */
 async function fetchExistingResults(dateStr, calcsInPass, fullManifest, config, { db }, includeSelf = false) {
     const manifestMap  = new Map(fullManifest.map(c => [normalizeName(c.name), c]));
     const calcsToFetch = new Set();
@@ -158,10 +136,6 @@ async function fetchExistingResults(dateStr, calcsInPass, fullManifest, config,
     return fetched;
 }
 
-/**
- * --- UPDATED: streamAndProcess ---
- * (Unchanged)
- */
 async function streamAndProcess(dateStr, state, passName, config, deps, rootData, portfolioRefs, historyRefs, fetchedDeps, previousFetchedDeps) {
     const { logger } = deps;
     const controller = new ComputationController(config, deps);
@@ -211,10 +185,6 @@ async function streamAndProcess(dateStr, state, passName, config, deps, rootData
     logger.log('INFO', `[${passName}] Streaming complete.`);
 }
 
-/**
- * --- UPDATED: runStandardComputationPass ---
- * Now accepts `skipStatusWrite` and returns `successUpdates`
- */
 async function runStandardComputationPass(date, calcs, passName, config, deps, rootData, fetchedDeps, previousFetchedDeps, skipStatusWrite = false) {
     const dStr = date.toISOString().slice(0, 10);
     const logger = deps.logger;
@@ -232,6 +202,9 @@ async function runStandardComputationPass(date, calcs, passName, config, deps, r
             const inst = new c.class(); 
             inst.manifest = c; 
             state[normalizeName(c.name)] = inst; 
+            
+            // LOG: Explicitly say what calculation is being processed (Initialized)
+            logger.log('INFO', `${c.name} calculation running for ${dStr}`);
         } 
         catch(e)  { 
             logger.log('WARN', `Failed to init ${c.name}`); 
@@ -240,14 +213,9 @@ async function runStandardComputationPass(date, calcs, passName, config, deps, r
 
     await streamAndProcess(dStr, state, passName, config, deps, fullRoot, rootData.portfolioRefs, rootData.historyRefs, fetchedDeps, previousFetchedDeps);
     
-    // Return the updates instead of just writing them
     return await commitResults(state, dStr, passName, config, deps, skipStatusWrite);
 }
 
-/**
- * --- UPDATED: runMetaComputationPass ---
- * Now accepts `skipStatusWrite` and returns `successUpdates`
- */
 async function runMetaComputationPass(date, calcs, passName, config, deps, fetchedDeps, previousFetchedDeps, rootData, skipStatusWrite = false) {
     const controller = new ComputationController(config, deps);
     const dStr       = date.toISOString().slice(0, 10);
@@ -255,6 +223,9 @@ async function runMetaComputationPass(date, calcs, passName, config, deps, fetch
 
     for (const mCalc of calcs) {
         try {
+            // LOG: Explicitly say what calculation is being processed
+            deps.logger.log('INFO', `${mCalc.name} calculation running for ${dStr}`);
+
             const inst = new mCalc.class();
             inst.manifest = mCalc;
             await controller.executor.executeOncePerDay(inst, mCalc, dStr, fetchedDeps, previousFetchedDeps);
@@ -267,7 +238,7 @@ async function runMetaComputationPass(date, calcs, passName, config, deps, fetch
 
 /**
  * --- UPDATED: commitResults ---
- * Added `skipStatusWrite` parameter. Returns `successUpdates`.
+ * Includes Explicit Result Logging and Honest Status Reporting.
  */
 async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false) {
     const writes = [], schemas = [], sharded = {};
@@ -277,14 +248,29 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
         const calc = stateObj[name];
         try {
             const result = await calc.getResult(); 
-            if (!result) continue;
+            
+            // If null/undefined, log as Failed/Unknown immediately
+            if (!result) {
+                deps.logger.log('INFO', `${name} calculation for ${dStr} ran, result : Failed (Empty Result)`);
+                continue;
+            }
+            
             const standardRes = {};
+            let hasData = false;
+
             for (const key in result) {
                 if (key.startsWith('sharded_')) {
                     const sData = result[key];
-                    for (const c in sData) { sharded[c] = sharded[c] || {}; Object.assign(sharded[c], sData[c]); }
-                } else standardRes[key] = result[key];
+                    for (const c in sData) { 
+                        sharded[c] = sharded[c] || {}; 
+                        Object.assign(sharded[c], sData[c]); 
+                    }
+                    if (Object.keys(sData).length > 0) hasData = true;
+                } else {
+                    standardRes[key] = result[key];
+                }
             }
+
             if (Object.keys(standardRes).length) {
                 standardRes._completed = true;
                 writes.push({
@@ -293,7 +279,9 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                         .collection(config.computationsSubcollection).doc(name),
                     data: standardRes
                 });
+                hasData = true;
             }
+            
             if (calc.manifest.class.getSchema) {
                 const { class: _cls, ...safeMetadata } = calc.manifest;
                 schemas.push({ 
@@ -304,9 +292,19 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                 });
             }
             
-            successUpdates[name] = true;
+            // --- EXPLICIT LOGGING & STATUS UPDATE ---
+            if (hasData) {
+                successUpdates[name] = true;
+                deps.logger.log('INFO', `${name} calculation for ${dStr} ran, result : Succeeded`);
+            } else {
+                // It ran without error, but produced no content (e.g. no data met criteria)
+                deps.logger.log('INFO', `${name} calculation for ${dStr} ran, result : Unknown (No Data Written)`);
+            }
 
-        } catch (e) { deps.logger.log('ERROR', `Commit failed ${name}: ${e.message}`); }
+        } catch (e) { 
+            deps.logger.log('ERROR', `Commit failed ${name}: ${e.message}`);
+            deps.logger.log('INFO', `${name} calculation for ${dStr} ran, result : Failed (Exception)`);
+        }
     }
 
     if (schemas.length) batchStoreSchemas(deps, config, schemas).catch(()=>{});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.182",
+  "version": "1.0.184",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [