bulltrackers-module 1.0.220 → 1.0.221

package/functions/computation-system/context/ContextFactory.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Factory for creating the Computation Context.
  */
-const mathLayer = require('../layers/index');
+const mathLayer          = require('../layers/index');
 const { LEGACY_MAPPING } = require('../topology/HashManager');
 
 class ContextFactory { 

package/functions/computation-system/context/ManifestBuilder.js

@@ -2,7 +2,7 @@
  * @fileoverview Dynamic Manifest Builder - Handles Topological Sort and Auto-Discovery.
  */
 const { generateCodeHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
-const { normalizeName } = require('../utils/utils');
+const { normalizeName }                    = require('../utils/utils');
 
 // Import Layers
 const MathematicsLayer = require('../layers/mathematics');
@@ -93,12 +93,12 @@ function buildManifest(productLinesToRun = [], calculations) {
         if (!Class || typeof Class !== 'function') return;
         const normalizedName = normalizeName(name);
         
-        if (typeof Class.getMetadata !== 'function') { log.fatal(`Calculation "${normalizedName}" missing static getMetadata().`); hasFatalError = true; return; }
+        if (typeof Class.getMetadata     !== 'function') { log.fatal(`Calculation "${normalizedName}" missing static getMetadata().`);     hasFatalError = true; return; }
         if (typeof Class.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" missing static getDependencies().`); hasFatalError = true; return; }
         
-        const metadata = Class.getMetadata();
+        const metadata     = Class.getMetadata();
         const dependencies = Class.getDependencies().map(normalizeName);
-        const codeStr = Class.toString();
+        const codeStr      = Class.toString();
         
         let compositeHashString = generateCodeHash(codeStr); 
         const usedDeps = [];

package/functions/computation-system/data/CachedDataLoader.js

@@ -15,7 +15,7 @@ class CachedDataLoader {
         this.cache = { 
             mappings: null, 
             insights: new Map(), 
-            social: new Map() 
+            social:   new Map()
         }; 
     }
 

package/functions/computation-system/executors/MetaExecutor.js

@@ -1,10 +1,10 @@
 /**
  * @fileoverview Executor for "Meta" (global) calculations.
  */
-const { normalizeName } = require('../utils/utils');
+const { normalizeName }    = require('../utils/utils');
 const { CachedDataLoader } = require('../data/CachedDataLoader');
-const { ContextFactory } = require('../context/ContextFactory');
-const { commitResults } = require('../persistence/ResultCommitter');
+const { ContextFactory }   = require('../context/ContextFactory');
+const { commitResults }    = require('../persistence/ResultCommitter');
 
 class MetaExecutor {
     static async run(date, calcs, passName, config, deps, fetchedDeps, previousFetchedDeps, rootData, skipStatusWrite = false) {

package/functions/computation-system/executors/PriceBatchExecutor.js

@@ -1,17 +1,17 @@
 /**
  * @fileoverview Specialized Executor for Price-Dependent Batch computations.
  */
-const pLimit = require('p-limit');
-const { normalizeName } = require('../utils/utils');
+const pLimit                                   = require('p-limit');
+const { normalizeName }                        = require('../utils/utils');
 const { getRelevantShardRefs, loadDataByRefs } = require('../utils/data_loader');
-const { CachedDataLoader } = require('../data/CachedDataLoader');
-const mathLayer = require('../layers/index');
-const { LEGACY_MAPPING } = require('../topology/HashManager');
+const { CachedDataLoader }                     = require('../data/CachedDataLoader');
+const mathLayer                                = require('../layers/index');
+const { LEGACY_MAPPING }                       = require('../topology/HashManager');
 
 async function runBatchPriceComputation(config, deps, dateStrings, calcs, targetTickers = []) {
     const { logger, db, calculationUtils } = deps;
     const cachedLoader = new CachedDataLoader(config, deps);
-    const mappings = await cachedLoader.loadMappings();
+    const mappings     = await cachedLoader.loadMappings();
     
     let targetInstrumentIds = [];
     if (targetTickers && targetTickers.length > 0) {

package/functions/computation-system/executors/StandardExecutor.js

@@ -1,23 +1,23 @@
 /**
  * @fileoverview Executor for "Standard" (per-user) calculations.
  */
-const { normalizeName } = require('../utils/utils');
+const { normalizeName }                                                = require('../utils/utils');
 const { streamPortfolioData, streamHistoryData, getPortfolioPartRefs } = require('../utils/data_loader');
-const { CachedDataLoader } = require('../data/CachedDataLoader');
-const { ContextFactory } = require('../context/ContextFactory');
-const { commitResults } = require('../persistence/ResultCommitter');
-const mathLayer = require('../layers/index');
+const { CachedDataLoader }                                             = require('../data/CachedDataLoader');
+const { ContextFactory }                                               = require('../context/ContextFactory');
+const { commitResults }                                                = require('../persistence/ResultCommitter');
+const mathLayer                                                        = require('../layers/index');
 
 class StandardExecutor {
     static async run(date, calcs, passName, config, deps, rootData, fetchedDeps, previousFetchedDeps, skipStatusWrite = false) {
-        const dStr = date.toISOString().slice(0, 10);
+        const dStr   = date.toISOString().slice(0, 10);
         const logger = deps.logger;
         
         // 1. Prepare Yesterdays Data if needed
         const fullRoot = { ...rootData };
         if (calcs.some(c => c.isHistorical)) {
-            const prev = new Date(date); prev.setUTCDate(prev.getUTCDate() - 1);
-            const prevStr = prev.toISOString().slice(0, 10);
+            const prev                      = new Date(date); prev.setUTCDate(prev.getUTCDate() - 1);
+            const prevStr                   = prev.toISOString().slice(0, 10);
             fullRoot.yesterdayPortfolioRefs = await getPortfolioPartRefs(config, deps, prevStr);
         }
 
@@ -53,19 +53,15 @@ class StandardExecutor {
         const cachedLoader = new CachedDataLoader(config, deps);
         await cachedLoader.loadMappings();
         
-        const prevDate = new Date(dateStr + 'T00:00:00Z'); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
+        const prevDate    = new Date(dateStr + 'T00:00:00Z'); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr = prevDate.toISOString().slice(0, 10);
         
-        const tP_iter = streamPortfolioData(config, deps, dateStr, portfolioRefs);
+        const tP_iter                 = streamPortfolioData(config, deps, dateStr, portfolioRefs);
         const needsYesterdayPortfolio = streamingCalcs.some(c => c.manifest.isHistorical);
-        const yP_iter = (needsYesterdayPortfolio && rootData.yesterdayPortfolioRefs) 
-            ? streamPortfolioData(config, deps, prevDateStr, rootData.yesterdayPortfolioRefs) 
-            : null;
+        const yP_iter                 = (needsYesterdayPortfolio && rootData.yesterdayPortfolioRefs)  ? streamPortfolioData(config, deps, prevDateStr, rootData.yesterdayPortfolioRefs) : null;
         
         const needsTradingHistory = streamingCalcs.some(c => c.manifest.rootDataDependencies.includes('history'));
-        const tH_iter = (needsTradingHistory && historyRefs) 
-            ? streamHistoryData(config, deps, dateStr, historyRefs) 
-            : null;
+        const tH_iter = (needsTradingHistory && historyRefs) ? streamHistoryData(config, deps, dateStr, historyRefs) : null;
 
         let yP_chunk = {}, tH_chunk = {};
         
@@ -74,9 +70,7 @@ class StandardExecutor {
             if (tH_iter) tH_chunk = (await tH_iter.next()).value || {};
             
             // Execute chunk for all calcs
-            const promises = streamingCalcs.map(calc => 
-                StandardExecutor.executePerUser(calc, calc.manifest, dateStr, tP_chunk, yP_chunk, tH_chunk, fetchedDeps, previousFetchedDeps, config, deps, cachedLoader)
-            );
+            const promises = streamingCalcs.map(calc =>  StandardExecutor.executePerUser(calc, calc.manifest, dateStr, tP_chunk, yP_chunk, tH_chunk, fetchedDeps, previousFetchedDeps, config, deps, cachedLoader) );
             await Promise.all(promises);
         }
         logger.log('INFO', `[${passName}] Streaming complete.`);
@@ -87,12 +81,12 @@ class StandardExecutor {
         const targetUserType = metadata.userType; 
         const mappings = await loader.loadMappings();
         const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await loader.loadInsights(dateStr) } : null;
-        const SCHEMAS = mathLayer.SCHEMAS;
+        const SCHEMAS  = mathLayer.SCHEMAS;
 
         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;
+            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;

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

@@ -5,8 +5,8 @@
  */
 
 const { getExpectedDateStrings } = require('../utils/utils.js');
-const { groupByPass } = require('../WorkflowOrchestrator.js');
-const { PubSubUtils } = require('../../core/utils/pubsub_utils');
+const { groupByPass }            = require('../WorkflowOrchestrator.js');
+const { PubSubUtils }            = require('../../core/utils/pubsub_utils');
 
 const TOPIC_NAME = 'computation-tasks';
 
@@ -15,14 +15,14 @@ const TOPIC_NAME = 'computation-tasks';
  * Instead of running them, it queues them in Pub/Sub.
  */
 async function dispatchComputationPass(config, dependencies, computationManifest) {
-    const { logger } = dependencies;
+    const { logger }  = dependencies;
     const pubsubUtils = new PubSubUtils(dependencies);
-    const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
+    const passToRun   = String(config.COMPUTATION_PASS_TO_RUN);
     
     if (!passToRun) { return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.'); }
 
     // 1. Validate Pass Existence
-    const passes = groupByPass(computationManifest);
+    const passes          = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
 
     if (!calcsInThisPass.length) { return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`); }

package/functions/computation-system/persistence/FirestoreUtils.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Low-level Firestore interactions.
  */
-const { withRetry } = require('../utils/utils.js'); // Assuming this exists or is passed in deps
+const { withRetry } = require('../utils/utils.js'); 
 
 async function commitBatchInChunks(config, deps, writes, operationName) {
     const { db, logger, calculationUtils } = deps;
@@ -12,13 +12,13 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
         return;
     }
 
-    const MAX_BATCH_OPS = 300;
+    const MAX_BATCH_OPS   = 300;
     const MAX_BATCH_BYTES = 9 * 1024 * 1024; 
 
-    let currentBatch = db.batch();
+    let currentBatch    = db.batch();
     let currentOpsCount = 0;
     let currentBytesEst = 0;
-    let batchIndex = 1;
+    let batchIndex      = 1;
 
     const commitAndReset = async () => {
         if (currentOpsCount > 0) {
@@ -34,7 +34,7 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
                 throw err;
             }
         }
-        currentBatch = db.batch();
+        currentBatch    = db.batch();
         currentOpsCount = 0;
         currentBytesEst = 0;
     };

package/functions/computation-system/persistence/ResultCommitter.js

@@ -1,13 +1,13 @@
 /**
  * @fileoverview Handles saving computation results with transparent auto-sharding.
  */
-const { commitBatchInChunks } = require('./FirestoreUtils');
+const { commitBatchInChunks }     = require('./FirestoreUtils');
 const { updateComputationStatus } = require('./StatusRepository');
-const { batchStoreSchemas } = require('../utils/schema_capture');
+const { batchStoreSchemas }       = require('../utils/schema_capture');
 
 async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false) {
     const successUpdates = {};
-    const schemas = [];
+    const schemas        = [];
 
     for (const name in stateObj) {
         const calc = stateObj[name];
@@ -40,7 +40,7 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             if (updates.length > 0) {
                 await commitBatchInChunks(config, deps, updates, `${name} Results`);
                 successUpdates[name] = calc.manifest.hash || true;
-                const isSharded = updates.some(u => u.data._sharded === true);
+                const isSharded      = updates.some(u => u.data._sharded === true);
                 deps.logger.log('INFO', `${name} for ${dStr}: \u2714 Success (Written ${isSharded ? 'Sharded' : 'Standard'})`);
             } else {
                 deps.logger.log('INFO', `${name} for ${dStr}: - Empty Data`);
@@ -74,42 +74,43 @@ function calculateFirestoreBytes(value) {
 
 async function prepareAutoShardedWrites(result, docRef, logger) {
     const SAFETY_THRESHOLD_BYTES = 1000 * 1024; // 1MB Limit
-    const OVERHEAD_ALLOWANCE = 20 * 1024;
-    const CHUNK_LIMIT = SAFETY_THRESHOLD_BYTES - OVERHEAD_ALLOWANCE;
-    const totalSize = calculateFirestoreBytes(result);
-    const docPathSize = Buffer.byteLength(docRef.path, 'utf8') + 16;
-
-    if ((totalSize + docPathSize) < CHUNK_LIMIT) { 
-        const data = { ...result, _completed: true, _sharded: false }; 
-        return [{ ref: docRef, data, options: { merge: true } }]; 
-    }
+    const OVERHEAD_ALLOWANCE     = 20 * 1024;
+    const CHUNK_LIMIT            = SAFETY_THRESHOLD_BYTES - OVERHEAD_ALLOWANCE;
+    const totalSize              = calculateFirestoreBytes(result);
+    const docPathSize            = Buffer.byteLength(docRef.path, 'utf8') + 16;
+    const writes                 = [];
+    const shardCollection        = docRef.collection('_shards');
+    let currentChunk             = {};
+    let currentChunkSize         = 0;
+    let shardIndex               = 0;
+
+    // If under limit, write directly
+    if ((totalSize + docPathSize) < CHUNK_LIMIT) {  const data = { ...result, _completed: true, _sharded: false };  return [{ ref: docRef, data, options: { merge: true } }];  }
 
     logger.log('INFO', `[AutoShard] Result size ~${Math.round(totalSize/1024)}KB exceeds limit. Sharding...`);
-    const writes = [];
-    const shardCollection = docRef.collection('_shards');
-    let currentChunk = {};
-    let currentChunkSize = 0;
-    let shardIndex = 0;
 
+    // iF over limit, shard the document
     for (const [key, value] of Object.entries(result)) { 
         if (key.startsWith('_')) continue;
-        const keySize = Buffer.byteLength(key, 'utf8') + 1;         
+        const keySize   = Buffer.byteLength(key, 'utf8') + 1;         
         const valueSize = calculateFirestoreBytes(value);
-        const itemSize = keySize + valueSize;
+        const itemSize  = keySize + valueSize;
 
+        // If adding this item exceeds the chunk limit, commit current chunk
         if (currentChunkSize + itemSize > CHUNK_LIMIT) { 
             writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });
             shardIndex++;
-            currentChunk = {};
+            currentChunk     = {};
             currentChunkSize = 0;
         }
         currentChunk[key] = value;
         currentChunkSize += itemSize;
     }
-    if (Object.keys(currentChunk).length > 0) { 
-        writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } }); 
-    }
+
+    // Write the final chunk
+    if (Object.keys(currentChunk).length > 0) {  writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });  }
     
+    // Finally, write the pointer document
     const pointerData = { _completed: true, _sharded: true, _shardCount: shardIndex + 1, _lastUpdated: new Date().toISOString() };
     writes.push({ ref: docRef, data: pointerData, options: { merge: false } });
     return writes;

package/functions/computation-system/persistence/StatusRepository.js

@@ -3,19 +3,25 @@
  */
 
 async function fetchComputationStatus(dateStr, config, { db }) {
-    if (!key) throw new Error('fetchStatus requires a key'); 
+    // FIX: Check dateStr directly, or define 'key' before checking it.
+    if (!dateStr) throw new Error('fetchStatus requires a key'); 
+    
     const key = dateStr;
     const collection = config.computationStatusCollection || 'computation_status';
     const docRef = db.collection(collection).doc(key);
+    
     const snap = await docRef.get();
     return snap.exists ? snap.data() : {};
 }
 
 async function updateComputationStatus(dateStr, updates, config, { db }) {
     if (!dateStr) throw new Error('updateStatus requires a key');
+    
     if (!updates || Object.keys(updates).length === 0) return;
+    
     const collection = config.computationStatusCollection || 'computation_status';
     const docRef = db.collection(collection).doc(dateStr);
+    
     await docRef.set(updates, { merge: true });
     return true;
 }

package/functions/computation-system/utils/utils.js

@@ -3,7 +3,7 @@
  */
 
 const { FieldValue, FieldPath } = require('@google-cloud/firestore');
-const crypto = require('crypto');
+const crypto                    = require('crypto');
 
 /** Stage 1: Normalize a calculation name to kebab-case */
 function normalizeName(name) { return name.replace(/_/g, '-'); }

package/package.json

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