bulltrackers-module 1.0.104 → 1.0.106

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

@@ -1,191 +0,0 @@
-/**
- * @fileoverview Builds a true Directed Acyclic Graph (DAG) for computations.
- *
- * This refactored utility ingests calculation classes and a dependency config.
- * It builds an adjacency list, performs a topological sort (Kahn's algorithm)
- * to detect cycles, and provides the graph structure to the orchestrator and worker.
- */
-
-/**
- * Represents a single calculation node in the graph.
- */
-class ComputationNode {
-    constructor(category, name, calcClass) {
-        this.category = category;
-        this.name = name;
-        this.calcClass = calcClass;
-        this.children = new Set(); // Nodes that depend on this one
-        this.parents = new Set();  // Nodes this one depends on
-        this.requires = []; // <-- ADDED: Stores data requirements
-    }
-}
-
-/**
- * Builds and validates the computation DAG.
- */
-class ComputationGraph {
-    /**
-     * @param {object} unifiedCalculations - The calculations object from 'aiden-shared-calculations-unified'.
-     * @param {object} dependencyConfig - The JSON config object with dependency definitions.
-     * @param {object} [logger=console] - A logger instance.
-     */
-    constructor(unifiedCalculations, dependencyConfig, logger = console) {
-        this.logger = logger;
-        this.nodes = new Map(); // Map<string, ComputationNode>
-        this.sortedNodes = []; // Array of node names, in valid execution order
-        this.isBuilt = false;
-
-        // --- MODIFIED: Pass requirements config to _registerNodes ---
-        this._registerNodes(unifiedCalculations, dependencyConfig.requirements || {});
-        this._buildAdjacencyLists(dependencyConfig.dependencies || {});
-    }
-
-    /**
-     * Pass 1: Register all calculations as nodes in the graph.
-     * --- MODIFIED: Added requirementsConfig parameter ---
-     */
-    _registerNodes(unifiedCalculations, requirementsConfig) {
-        this.logger.log('INFO', '[DepGraph] Pass 1: Registering all calculation nodes...');
-        for (const category in unifiedCalculations) {
-            if (category === 'utils') continue;
-
-            for (const subKey in unifiedCalculations[category]) {
-                const item = unifiedCalculations[category][subKey];
-
-                // Handle nested directories (e.g., 'historical', 'meta', 'backtests')
-                if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
-                    for (const calcName in item) {
-                        if (typeof item[calcName] === 'function') {
-                            // --- MODIFIED: Create node, set requirements ---
-                            const node = new ComputationNode(category, calcName, item[calcName]);
-                            node.requires = requirementsConfig[calcName] || [];
-                            this.nodes.set(calcName, node);
-                            // --- END MODIFICATION ---
-                        }
-                    }
-                }
-                // Handle regular calcs at the root of the category
-                else if (typeof item === 'function') {
-                    const calcName = subKey;
-                    // --- MODIFIED: Create node, set requirements ---
-                    const node = new ComputationNode(category, calcName, item[calcName]);
-                    node.requires = requirementsConfig[calcName] || [];
-                    this.nodes.set(calcName, node);
-                    // --- END MODIFICATION ---
-                }
-            }
-        }
-        this.logger.log('INFO', `[DepGraph] Pass 1: Registered ${this.nodes.size} total nodes.`);
-    }
-
-    /**
-     * Pass 2: Build parent/child relationships from the dependency config.
-     * (This function remains unchanged as it only reads the 'dependencies' key)
-     */
-    _buildAdjacencyLists(dependencies) {
-        this.logger.log('INFO', '[DepGraph] Pass 2: Building adjacency lists...');
-        for (const nodeName in dependencies) {
-            const parentNames = dependencies[nodeName];
-            const childNode = this.nodes.get(nodeName);
-
-            if (!childNode) {
-                this.logger.log('WARN', `[DepGraph] Dependency config lists node "${nodeName}", but it was not found in registered calculations. Skipping.`);
-                continue;
-            }
-
-            for (const parentName of parentNames) {
-                const parentNode = this.nodes.get(parentName);
-                if (!parentNode) {
-                    this.logger.log('WARN', `[DepGraph] Node "${nodeName}" lists dependency "${parentName}", but it was not found. Skipping dependency.`);
-                    continue;
-                }
-
-                // Create the links
-                childNode.parents.add(parentName);
-                parentNode.children.add(nodeName);
-            }
-        }
-        this.logger.log('INFO', '[DepGraph] Pass 2: Adjacency lists built.');
-    }
-
-    /**
-     * Pass 3: Perform Topological Sort (Kahn's Algorithm) to find execution order
-     * and detect cycles. This is the "build" step.
-     * (This function remains unchanged)
-     */
-    build() {
-        if (this.isBuilt) return;
-        this.logger.log('INFO', '[DepGraph] Pass 3: Running topological sort (Kahn\'s Algorithm)...');
-
-        const inDegree = new Map(); // Map<string, number>
-        const queue = []; // Queue of node names
-
-        // Initialize in-degree (parent count) for all nodes
-        for (const [name, node] of this.nodes.entries()) {
-            inDegree.set(name, node.parents.size);
-            if (node.parents.size === 0) {
-                queue.push(name);
-            }
-        }
-
-        while (queue.length > 0) {
-            const nodeName = queue.shift();
-            this.sortedNodes.push(nodeName);
-
-            const node = this.nodes.get(nodeName);
-            if (!node) continue;
-
-            for (const childName of node.children) {
-                const newDegree = inDegree.get(childName) - 1;
-                inDegree.set(childName, newDegree);
-                if (newDegree === 0) {
-                    queue.push(childName);
-                }
-            }
-        }
-
-        // Check for cycles
-        if (this.sortedNodes.length < this.nodes.size) {
-            const missing = [...this.nodes.keys()].filter(n => !this.sortedNodes.includes(n));
-            this.logger.log('ERROR', `[DepGraph] CRITICAL: Cycle detected! ${missing.length} nodes could not be sorted.`, {
-                unprocessedNodes: missing
-            });
-            throw new Error(`Cycle detected in computation graph. Unprocessed nodes: ${missing.join(', ')}`);
-        }
-
-        this.logger.log('SUCCESS', `[DepGraph] Pass 3: Topological sort complete. Valid DAG confirmed.`);
-        this.isBuilt = true;
-    }
-
-    /**
-     * Returns all nodes that have no dependencies (graph roots).
-     * @returns {ComputationNode[]}
-     */
-    getRootNodes() {
-        if (!this.isBuilt) this.build();
-        return this.sortedNodes
-            .map(name => this.nodes.get(name))
-            .filter(node => node.parents.size === 0);
-    }
-
-    /**
-     * Returns a node by its name.
-     * @param {string} nodeName
-     * @returns {ComputationNode | undefined}
-     */
-    getNode(nodeName) {
-        return this.nodes.get(nodeName);
-    }
-
-    /**
-     * Returns all registered node objects.
-     * @returns {ComputationNode[]}
-     */
-    getAllNodes() {
-        return Array.from(this.nodes.values());
-    }
-}
-
-module.exports = {
-    ComputationGraph
-};

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

@@ -1,160 +0,0 @@
-/**
- * @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 };
-}