bulltrackers-module 1.0.106 → 1.0.108

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

@@ -6,6 +6,9 @@
  * passes computed dependencies in-memory.
  * NEW: Checks for root data (portfolios, insights, social)
  * before processing any calculations for a given day.
+ *
+ * MODIFICATION: Meta calculations now receive rootData in their
+ * dependencies object to allow them to stream users.
  */
 
 const { FieldPath } = require('@google-cloud/firestore');
@@ -161,7 +164,8 @@ async function runComputationOrchestrator(config, dependencies, computationManif
                         `Pass ${passNum} (Meta)`,
                         config,
                         dependencies,
-                        dailyResultsCache // <-- PASS THE CACHE
+                        dailyResultsCache, // <-- PASS THE CACHE
+                        rootData // <--- !! MODIFICATION: PASS rootData !!
                     );
 
                     // Add results to cache
@@ -540,9 +544,18 @@ async function runUnifiedComputation(dateToProcess, calculationsToRun, passName,
 /**
  * Internal sub-pipe: Runs "meta" or "backtest" computations for a single date.
  * MODIFIED: Accepts in-memory cache and passes dependencies to calcs.
+ * MODIFIED: Accepts rootData and adds it to the dependencies object.
  * Returns a map of results.
  */
-async function runMetaComputation(dateToProcess, calculationsToRun, passName, config, dependencies, dailyResultsCache) {
+async function runMetaComputation(
+    dateToProcess, 
+    calculationsToRun, 
+    passName, 
+    config, 
+    dependencies, 
+    dailyResultsCache,
+    rootData // <--- !! MODIFICATION: ACCEPT rootData !!
+) {
     const { db, logger } = dependencies;
     const dateStr = dateToProcess.toISOString().slice(0, 10);
     logger.log('INFO', `[${passName}] Starting run for ${dateStr} with ${calculationsToRun.length} calcs.`);
@@ -552,6 +565,13 @@ async function runMetaComputation(dateToProcess, calculationsToRun, passName, co
     try {
         const resultsCollectionRef = db.collection(config.resultsCollection).doc(dateStr).collection(config.resultsSubcollection);
         let successCount = 0;
+        
+        // --- !! MODIFICATION: Add rootData to the dependencies object !! ---
+        const dependenciesForMetaCalc = {
+            ...dependencies,
+            rootData: rootData
+        };
+        // --- END MODIFICATION ---
 
         for (const manifestCalc of calculationsToRun) {
             const calcName = normalizeName(manifestCalc.name);
@@ -586,7 +606,7 @@ async function runMetaComputation(dateToProcess, calculationsToRun, passName, co
                 // --- Call process with the dependencies ---
                 const result = await Promise.resolve(instance.process(
                     dateStr, 
-                    dependencies, 
+                    dependenciesForMetaCalc, // <-- PASS MODIFIED DEPS
                     config, 
                     computedDependencies // <-- PASS IN-MEMORY DEPS
                 ));

package/functions/speculator-cleanup-orchestrator/helpers/cleanup_helpers.js

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Main pipe: pipe.maintenance.runSpeculatorCleanup
+ * REFACTORED: Now stateless and receives dependencies.
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+/**
+ * Main pipe: pipe.maintenance.runSpeculatorCleanup
+ * Orchestrates the cleanup process.
+ * @param {object} config - Configuration object.
+ * @param {object} dependencies - Contains db, logger.
+ */
+exports.runCleanup = async (config, dependencies) => {
+    const { logger } = dependencies;
+    logger.log('INFO', '[CleanupHelpers] Running cleanup orchestrator...');
+
+    try {
+        // Start cleanup for pending users
+        const { batch: batchAfterPending, count: pendingRemoved } = await cleanupPendingSpeculators(config, dependencies);
+
+        // Continue with the same batch for stale speculators
+        const { batch: finalBatch, count: staleRemoved } = await cleanupStaleSpeculators(config, dependencies, batchAfterPending);
+
+        if (pendingRemoved > 0 || staleRemoved > 0) {
+            await finalBatch.commit();
+            logger.log('SUCCESS', `[CleanupHelpers] Cleanup commit successful. Removed ${pendingRemoved} pending, ${staleRemoved} stale speculators.`);
+            return { pendingRemoved, staleRemoved };
+        } else {
+            logger.log('SUCCESS', '[CleanupHelpers] No stale users found in pending or blocks.');
+            return { pendingRemoved: 0, staleRemoved: 0 };
+        }
+    } catch (error) {
+        logger.log('ERROR', '[CleanupHelpers] FATAL error during cleanup orchestration', { errorMessage: error.message, errorStack: error.stack });
+        throw error;
+    }
+};
+
+/**
+ * Internal sub-pipe for cleaning pending speculators.
+ */
+async function cleanupPendingSpeculators(config, dependencies) {
+    const { db, logger } = dependencies;
+    logger.log('INFO', '[CleanupHelpers] Starting pending speculator cleanup...');
+    
+    const batch = db.batch(); // Use db from dependencies
+    let stalePendingUsersRemoved = 0;
+    const pendingCollectionRef = db.collection(config.pendingSpeculatorsCollectionName); // Use db
+    const staleThreshold = new Date();
+    staleThreshold.setHours(staleThreshold.getHours() - config.pendingGracePeriodHours);
+
+    try {
+        const pendingSnapshot = await pendingCollectionRef.get();
+        if (pendingSnapshot.empty) {
+            logger.log('INFO', '[CleanupHelpers] Pending speculators collection is empty.');
+            return { batch, count: 0 };
+        }
+
+        for (const doc of pendingSnapshot.docs) {
+            const pendingData = doc.data().users || {};
+            const updates = {};
+            let updatesInDoc = 0;
+
+            for (const userId in pendingData) {
+                const timestamp = pendingData[userId]?.toDate ? pendingData[userId].toDate() : null;
+                if (timestamp && timestamp < staleThreshold) {
+                    updates[`users.${userId}`] = FieldValue.delete();
+                    stalePendingUsersRemoved++;
+                    updatesInDoc++;
+                }
+            }
+
+            if (updatesInDoc > 0) {
+                 logger.log('TRACE', `[CleanupHelpers] Marking ${updatesInDoc} users for removal from pending doc ${doc.id}`);
+                batch.update(doc.ref, updates);
+            }
+        }
+        logger.log('INFO', `[CleanupHelpers] Marked ${stalePendingUsersRemoved} total stale pending users for removal.`);
+    } catch (error) {
+         logger.log('ERROR', '[CleanupHelpers] Error cleaning pending speculators', { errorMessage: error.message });
+         throw error;
+    }
+    return { batch, count: stalePendingUsersRemoved };
+}
+
+/**
+ * Internal sub-pipe for cleaning stale speculators.
+ */
+async function cleanupStaleSpeculators(config, dependencies, batch) {
+    const { db, logger } = dependencies;
+    logger.log('INFO', '[CleanupHelpers] Starting stale speculator cleanup from blocks...');
+    let totalUsersRemoved = 0;
+    const blocksCollectionRef = db.collection(config.speculatorBlocksCollectionName); // Use db
+    const gracePeriodDate = new Date();
+    gracePeriodDate.setDate(gracePeriodDate.getDate() - config.activityGracePeriodDays);
+    const blockCountsUpdate = {}; 
+
+    try {
+        const blocksSnapshot = await blocksCollectionRef.get();
+        if (blocksSnapshot.empty) {
+             logger.log('INFO', '[CleanupHelpers] Speculator blocks collection is empty.');
+            return { batch, count: 0 };
+        }
+
+        for (const doc of blocksSnapshot.docs) {
+            const blockId = doc.id;
+            const blockData = doc.data();
+            const users = blockData.users || {};
+            let usersRemovedFromBlock = 0;
+            const updates = {}; 
+
+            for (const userKey in users) { 
+                const userId = userKey.split('.')[1];
+                if (!userId) continue; 
+
+                const userData = users[userKey];
+                const lastHeldTimestamp = userData.lastHeldSpeculatorAsset?.toDate ? userData.lastHeldSpeculatorAsset.toDate() : null;
+
+                if (lastHeldTimestamp && lastHeldTimestamp < gracePeriodDate) {
+                    updates[userKey] = FieldValue.delete();
+                    usersRemovedFromBlock++;
+
+                    if (userData.instruments && Array.isArray(userData.instruments)) {
+                        userData.instruments.forEach(instrumentId => {
+                            const instrumentBlockKey = `${instrumentId}_${blockId}`;
+                            if (!blockCountsUpdate[instrumentBlockKey]) {
+                                blockCountsUpdate[instrumentBlockKey] = 0;
+                            }
+                            blockCountsUpdate[instrumentBlockKey]--;
+                        });
+                    }
+                }
+            }
+
+            if (usersRemovedFromBlock > 0) {
+                logger.log('TRACE', `[CleanupHelpers] Marking ${usersRemovedFromBlock} users for removal from block ${blockId}.`);
+                batch.update(doc.ref, updates);
+                totalUsersRemoved += usersRemovedFromBlock;
+            }
+        }
+
+        if (totalUsersRemoved > 0 && Object.keys(blockCountsUpdate).length > 0) {
+            const countsRef = db.doc(config.speculatorBlockCountsDocPath); // Use db
+            const finalCountUpdates = {};
+            for (const key in blockCountsUpdate) {
+                finalCountUpdates[`counts.${key}`] = FieldValue.increment(blockCountsUpdate[key]);
+            }
+             logger.log('TRACE', '[CleanupHelpers] Staging block count decrements.', { updates: finalCountUpdates });
+            batch.set(countsRef, finalCountUpdates, { merge: true });
+        }
+
+        logger.log('INFO', `[CleanupHelpers] Marked ${totalUsersRemoved} total stale speculators for removal from blocks.`);
+
+    } catch (error) {
+        logger.log('ERROR', '[CleanupHelpers] Error cleaning stale speculators', { errorMessage: error.message });
+        throw error;
+    }
+
+    return { batch, count: totalUsersRemoved };
+}

package/package.json

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