bulltrackers-module 1.0.107 → 1.0.108

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.107",
+  "version": "1.0.108",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [