bulltrackers-module 1.0.768 → 1.0.770

package/functions/computation-system-v2/devtools/simulation/MockStorageManager.js

@@ -0,0 +1,336 @@
+/**
+ * @fileoverview Mock Storage Manager
+ * 
+ * Drop-in replacement for StorageManager that captures results in memory.
+ * Designed to be injected into the real Orchestrator for 1:1 simulation.
+ * 
+ * Key Features:
+ * - Implements same interface as StorageManager
+ * - Stores results in memory instead of BigQuery/Firestore
+ * - Provides access to captured results for inspection
+ * - Simulates computation_results table for pass dependencies
+ */
+
+class MockStorageManager {
+    /**
+     * @param {Object} options
+     * @param {Object} [options.config] - Storage config (for compatibility)
+     */
+    constructor(options = {}) {
+        this.config = options.config || {};
+
+        // In-memory result storage
+        // Structure: { computationName: { entityId: result } }
+        this.results = {};
+
+        // Full row storage (for computation_results table simulation)
+        // Structure: { computationName: Row[] }
+        this.resultRows = {};
+
+        // Checkpoint storage
+        this.checkpoints = {};
+
+        // Stats
+        this.stats = {
+            commitsCount: 0,
+            finalizationsCount: 0,
+            totalRowsStored: 0,
+            checkpointsSaved: 0
+        };
+
+        // Operation log for inspection
+        this.operationLog = [];
+    }
+
+    /**
+     * Stage results - matches StorageManager.commitResults signature.
+     * 
+     * @param {string} dateStr - Date string (YYYY-MM-DD)
+     * @param {Object} entry - Manifest entry { name, category, ... }
+     * @param {Object} results - { entityId: result }
+     * @param {Object} depResultHashes - Dependency result hashes
+     * @returns {Object} Write results
+     */
+    async commitResults(dateStr, entry, results, depResultHashes = {}) {
+        const computationName = entry.name.toLowerCase();
+        const startTime = Date.now();
+
+        this.operationLog.push({
+            operation: 'commitResults',
+            computation: computationName,
+            date: dateStr,
+            entityCount: Object.keys(results).length,
+            timestamp: new Date().toISOString()
+        });
+
+        // Store results
+        if (!this.results[computationName]) {
+            this.results[computationName] = {};
+        }
+        Object.assign(this.results[computationName], results);
+
+        // Build rows in computation_results format
+        const rows = this._buildBigQueryRows(dateStr, entry, results, depResultHashes);
+        if (!this.resultRows[computationName]) {
+            this.resultRows[computationName] = [];
+        }
+        this.resultRows[computationName].push(...rows);
+
+        this.stats.commitsCount++;
+        this.stats.totalRowsStored += Object.keys(results).length;
+
+        const duration = Date.now() - startTime;
+
+        return {
+            bigquery: { staged: true, rowCount: Object.keys(results).length },
+            firestore: { written: false },
+            duration
+        };
+    }
+
+    /**
+     * Finalize results - matches StorageManager.finalizeResults signature.
+     * For mock, this is a no-op since data is already stored in memory.
+     * 
+     * @param {string} dateStr
+     * @param {Object} entry
+     */
+    async finalizeResults(dateStr, entry) {
+        const computationName = entry.name;
+
+        this.operationLog.push({
+            operation: 'finalizeResults',
+            computation: computationName,
+            date: dateStr,
+            timestamp: new Date().toISOString()
+        });
+
+        this.stats.finalizationsCount++;
+
+        // No-op for mock - data already in memory
+        return { finalized: true };
+    }
+
+    // =========================================================================
+    // CHECKPOINT METHODS (Simplified for simulation)
+    // =========================================================================
+
+    async saveCheckpoint(state) {
+        const id = state.checkpointId || `mock_${Date.now()}`;
+        this.checkpoints[id] = {
+            ...state,
+            lastUpdated: new Date().toISOString()
+        };
+        this.stats.checkpointsSaved++;
+        return { saved: true, id };
+    }
+
+    async initCheckpoint(dateStr, computationName, checkpointId, totalEntities, workerId, codeHash) {
+        const checkpoint = {
+            dateStr,
+            computationName,
+            checkpointId,
+            totalEntities,
+            workerId,
+            codeHash,
+            status: 'RUNNING',
+            processedEntities: 0,
+            lastUpdated: new Date().toISOString()
+        };
+        this.checkpoints[checkpointId] = checkpoint;
+        return checkpoint;
+    }
+
+    async updateCheckpoint(dateStr, computationName, checkpointId, state) {
+        if (this.checkpoints[checkpointId]) {
+            Object.assign(this.checkpoints[checkpointId], state, {
+                lastUpdated: new Date().toISOString()
+            });
+        }
+        return { updated: true };
+    }
+
+    async updateHeartbeat(checkpointId, workerId) {
+        if (this.checkpoints[checkpointId]) {
+            this.checkpoints[checkpointId].lastHeartbeat = new Date().toISOString();
+        }
+        return { updated: true };
+    }
+
+    async completeCheckpoint(dateStr, computationName, checkpointId) {
+        if (this.checkpoints[checkpointId]) {
+            this.checkpoints[checkpointId].status = 'COMPLETED';
+            this.checkpoints[checkpointId].completedAt = new Date().toISOString();
+        }
+        return { completed: true };
+    }
+
+    async failCheckpoint(checkpointId, reason) {
+        if (this.checkpoints[checkpointId]) {
+            this.checkpoints[checkpointId].status = 'FAILED';
+            this.checkpoints[checkpointId].failureReason = reason;
+        }
+        return { failed: true };
+    }
+
+    async getLatestCheckpoint(dateStr, computationName) {
+        // Find matching checkpoint
+        for (const [id, cp] of Object.entries(this.checkpoints)) {
+            if (cp.dateStr === dateStr && cp.computationName === computationName) {
+                return cp;
+            }
+        }
+        return null;
+    }
+
+    async getLatestCheckpointById(checkpointId) {
+        return this.checkpoints[checkpointId] || null;
+    }
+
+    async findZombies(minutesThreshold = 15) {
+        return []; // No zombies in simulation
+    }
+
+    async claimZombie(checkpointId) {
+        return { claimed: false };
+    }
+
+    async claimCheckpoint(checkpointId, newWorkerId, minutesThreshold = 15) {
+        return { claimed: false };
+    }
+
+    // =========================================================================
+    // PERFORMANCE REPORTS
+    // =========================================================================
+
+    async savePerformanceReport(report) {
+        this.operationLog.push({
+            operation: 'savePerformanceReport',
+            report,
+            timestamp: new Date().toISOString()
+        });
+        return { saved: true };
+    }
+
+    // =========================================================================
+    // RESULT ACCESS METHODS (For simulation inspection)
+    // =========================================================================
+
+    /**
+     * Get results for a computation.
+     * @param {string} computationName
+     * @returns {Object} { entityId: result }
+     */
+    getResults(computationName) {
+        return this.results[computationName.toLowerCase()] || {};
+    }
+
+    /**
+     * Get all results across all computations.
+     * @returns {Object} { computationName: { entityId: result } }
+     */
+    getAllResults() {
+        return { ...this.results };
+    }
+
+    /**
+     * Get results as computation_results rows (for dependency simulation).
+     * @param {string} computationName
+     * @returns {Object[]} Rows in computation_results format
+     */
+    getResultRows(computationName) {
+        return this.resultRows[computationName.toLowerCase()] || [];
+    }
+
+    /**
+     * Get results keyed by entity ID (for feeding to dependent computations).
+     * This is what dependent computations receive when querying for metrics.
+     * @param {string} computationName
+     * @returns {Object} { entityId: result }
+     */
+    getResultsForDependency(computationName) {
+        const rows = this.resultRows[computationName.toLowerCase()] || [];
+        const byEntity = {};
+
+        for (const row of rows) {
+            byEntity[row.entity_id] = row.result;
+        }
+
+        return byEntity;
+    }
+
+    /**
+     * Clear all stored data.
+     */
+    clear() {
+        this.results = {};
+        this.resultRows = {};
+        this.checkpoints = {};
+        this.operationLog = [];
+        this.stats = {
+            commitsCount: 0,
+            finalizationsCount: 0,
+            totalRowsStored: 0,
+            checkpointsSaved: 0
+        };
+    }
+
+    /**
+     * Get storage statistics.
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+
+    /**
+     * Get operation log.
+     */
+    getOperationLog() {
+        return [...this.operationLog];
+    }
+
+    // =========================================================================
+    // PRIVATE METHODS
+    // =========================================================================
+
+    _buildBigQueryRows(dateStr, entry, results, depResultHashes) {
+        const rows = [];
+        const timestamp = new Date().toISOString();
+
+        for (const [entityId, result] of Object.entries(results)) {
+            rows.push({
+                date: dateStr,
+                computation_name: entry.name,
+                category: entry.category || 'unknown',
+                entity_id: entityId,
+                result: result,
+                dependency_hashes: JSON.stringify(depResultHashes),
+                hash: this._hashResult(result),
+                created_at: timestamp
+            });
+        }
+
+        return rows;
+    }
+
+    _hashResult(data) {
+        // Simple hash for mock purposes
+        const str = JSON.stringify(data) || '';
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const chr = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0;
+        }
+        return Math.abs(hash).toString(16);
+    }
+
+    /**
+     * Firestore accessor (returns dummy for compatibility).
+     */
+    get firestore() {
+        return null;
+    }
+}
+
+module.exports = { MockStorageManager };