bulltrackers-module 1.0.33 → 1.0.35

package/functions/generic-api/index.js

@@ -48,6 +48,73 @@ function createStructureSnippet(data, maxKeys = 20) {
     return newObj;
 }
 
+/**
+ * Reusable helper to fetch the structure for a single computation.
+ * @param {string} computationName
+ * @param {object} calcMap
+ * @param {object} config
+ * @param {Firestore} firestore
+ * @param {Logger} logger
+ * @returns {Promise<object>} A result object with status and data or error.
+ */
+async function getComputationStructure(computationName, calcMap, config, firestore, logger) {
+    try {
+        // 1. Find the computation category
+        const pathInfo = calcMap[computationName];
+        if (!pathInfo) {
+            return { status: 'error', computation: computationName, message: `Computation not found in calculation map.` };
+        }
+        const { category } = pathInfo;
+
+        // 2. Get collection names from config
+        const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+
+        // 3. Find the most recent date *that contains this computation*
+        const computationQueryPath = `${category}.${computationName}`;
+        const dateQuery = firestore.collection(insightsCollection)
+            .where(computationQueryPath, '==', true)
+            .orderBy(FieldPath.documentId(), 'desc')
+            .limit(1);
+            
+        const dateSnapshot = await dateQuery.get();
+
+        if (dateSnapshot.empty) {
+            return { status: 'error', computation: computationName, message: `No computed data found. (Query path: ${computationQueryPath})` };
+        }
+        
+        const latestStoredDate = dateSnapshot.docs[0].id;
+
+        // 4. Construct the path to the actual computation document
+        const docRef = firestore.collection(insightsCollection).doc(latestStoredDate)
+            .collection(resultsSub).doc(category)
+            .collection(compsSub).doc(computationName);
+
+        const doc = await docRef.get();
+
+        if (!doc.exists) {
+            return { status: 'error', computation: computationName, message: `Summary flag was present for ${latestStoredDate} but doc is missing.` };
+        }
+
+        // 5. Generate and return the snippet
+        const fullData = doc.data();
+        const structureSnippet = createStructureSnippet(fullData);
+
+        return {
+            status: 'success',
+            computation: computationName,
+            category: category,
+            latestStoredDate: latestStoredDate,
+            structureSnippet: structureSnippet,
+        };
+
+    } catch (error) {
+        logger.log('ERROR', `API /structure/${computationName} helper failed.`, { errorMessage: error.message });
+        return { status: 'error', computation: computationName, message: error.message };
+    }
+}
+
 
 /**
  * Creates and configures the Express app for the Generic API.
@@ -90,81 +157,80 @@ function createApiApp(config, dependencies, unifiedCalculations) {
         }
     });
 
-    // --- REVISED V3: Debug Endpoint to get the structure from Firestore ---
+    // --- REVISED: Debug Endpoint to get the structure from Firestore ---
     app.get('/structure/:computationName', async (req, res) => {
         const { computationName } = req.params;
-        try {
-            // 1. Find the computation category
-            const pathInfo = calcMap[computationName];
-            if (!pathInfo) {
-                return res.status(404).send({ status: 'error', message: `Computation '${computationName}' not found in calculation map.` });
-            }
-            const { category } = pathInfo;
-
-            // 2. Get collection names from config
-            const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
-            const resultsSub = config.resultsSubcollection || 'results';
-            const compsSub = config.computationsSubcollection || 'computations';
-
-            // 3. Find the most recent date *that contains this computation*
-            // This relies on the summary flags set by orchestration_helpers.js
-            const computationQueryPath = `${category}.${computationName}`;
-            const dateQuery = firestore.collection(insightsCollection)
-                .where(computationQueryPath, '==', true) // Find docs with the summary flag
-                .orderBy(FieldPath.documentId(), 'desc') // Get the latest date
-                .limit(1);
-                
-            const dateSnapshot = await dateQuery.get();
-
-            if (dateSnapshot.empty) {
-                return res.status(404).send({ 
-                    status: 'error', 
-                    message: `No computed data found for '${computationName}'. (Query path: ${computationQueryPath})`
-                });
-            }
-            
-            const latestDateForThisComp = dateSnapshot.docs[0].id;
-
-            // 4. Construct the path to the actual computation document
-            const docRef = firestore.collection(insightsCollection).doc(latestDateForThisComp)
-                .collection(resultsSub).doc(category)
-                .collection(compsSub).doc(computationName);
+        
+        const result = await getComputationStructure(computationName, calcMap, config, firestore, logger);
 
-            const doc = await docRef.get();
+        if (result.status === 'error') {
+            const statusCode = result.message.includes('not found') ? 404 : 500;
+            return res.status(statusCode).send(result);
+        }
+        
+        res.status(200).send(result);
+    });
 
-            if (!doc.exists) {
-                // This is unlikely if the summary flag is true, but good to check
-                return res.status(404).send({ 
-                    status: 'error', 
-                    message: `Data for '${computationName}' not found for its latest date (${latestDateForThisComp}). Summary flag was present but doc is missing.`,
-                    checkedPath: docRef.path
-                });
-            }
+    // --- NEW: Debug Endpoint to generate the full structure manifest ---
+    app.get('/manifest', async (req, res) => {
+        try {
+            const allKeys = Object.keys(calcMap).sort();
+            
+            // Run all structure fetches in parallel
+            const promises = allKeys.map(key => 
+                getComputationStructure(key, calcMap, config, firestore, logger)
+            );
+            
+            const results = await Promise.allSettled(promises);
+
+            const manifest = {};
+            const errors = [];
+            let successCount = 0;
+
+            results.forEach(result => {
+                if (result.status === 'fulfilled' && result.value.status === 'success') {
+                    const data = result.value;
+                    manifest[data.computation] = {
+                        category: data.category,
+                        latestStoredDate: data.latestStoredDate,
+                        structureSnippet: data.structureSnippet,
+                    };
+                    successCount++;
+                } else if (result.status === 'fulfilled') {
+                    // Handled error from our helper
+                    const errorData = result.value;
+                    errors.push({
+                        computation: errorData.computation,
+                        message: errorData.message,
+                    });
+                } else {
+                    // Promise rejected (unexpected error)
+                    errors.push({
+                        computation: "Unknown (Promise rejected)",
+                        message: result.reason.message,
+                    });
+                }
+            });
 
-            // 5. Generate and return the snippet
-            const fullData = doc.data();
-            const snippet = createStructureSnippet(fullData);
+            logger.log('INFO', `API /manifest complete. ${successCount}/${allKeys.length} computations successful.`);
 
             res.status(200).send({
                 status: 'success',
-                computation: computationName,
-                category: category,
-                latestStoredDate: latestDateForThisComp,
-                structureSnippet: snippet,
+                summary: {
+                    totalComputations: allKeys.length,
+                    successful: successCount,
+                    failed: errors.length,
+                },
+                manifest,
+                errors,
             });
 
         } catch (error) {
-            // Handle errors, including bad query paths
-            if (error.message && error.message.includes('Invalid argument')) {
-                 logger.log('ERROR', `API /structure/${computationName} failed, likely due to invalid query path.`, { queryPath: `${category}.${computationName}`, stack: error.stack });
-                 return res.status(500).send({ status: 'error', message: `Internal query error. The path '${category}.${computationName}' might be invalid.` });
-            }
-            logger.log('ERROR', `API /structure/${computationName} failed.`, { errorMessage: error.message, stack: error.stack });
-            res.status(500).send({ status: 'error', message: `An internal error occurred while processing '${computationName}'.` });
+            logger.log('ERROR', `API /manifest failed unexpectedly.`, { errorMessage: error.message, stack: error.stack });
+            res.status(500).send({ status: 'error', message: `An internal error occurred while building the manifest.` });
         }
     });
 
-
     return app;
 }
 

package/functions/task-engine/helpers/update_helpers.js

@@ -24,6 +24,15 @@ async function handleUpdate(task, taskId, clients, config) {
         
         logger.log('INFO', `[UPDATE] Fetching portfolio for user ${userId} (${userType} with url ${url})`);
         const { response } = await clients.proxyManager.fetch(url, { headers: selectedHeader.headers });
+        // Add this check
+        if (!response || typeof response.text !== 'function') {
+            // Log the problematic response object for debugging
+            logger.log('ERROR', `[UPDATE] Invalid or incomplete response received for user ${userId}`, { response });
+            // Decide how to handle this - maybe throw an error or return early
+            throw new Error(`Invalid response structure received from proxy for user ${userId}.`);
+        }
+
+        // Now it's safer to call .text()
         const responseBody = await response.text();
 
         if (responseBody.includes("user is PRIVATE")) {

package/package.json

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