bulltrackers-module 1.0.665 → 1.0.667

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

@@ -130,10 +130,16 @@ async function getStableDateSession(config, dependencies, pass, dateLimitStr, fo
 // HANDLERS
 // =============================================================================
 
-// 2. NEW SNAPSHOT HANDLER
+// 2. NEW SNAPSHOT HANDLER (Asynchronous with Callback)
 async function handleSnapshot(config, dependencies, reqBody) {
     const { logger } = dependencies;
     const targetDate = reqBody.date; // Optional: if provided, only process up to this date
+    const callbackUrl = reqBody.callback_url; // Callback URL from workflow
+    
+    logger.log('INFO', `[Dispatcher] 📸 Snapshot request received. Date: ${targetDate || 'all'}, Callback URL: ${callbackUrl || 'NOT PROVIDED'}`);
+    
+    // Use native fetch if available (Node 18+), otherwise fall back to node-fetch
+    const directFetch = typeof fetch !== 'undefined' ? fetch : require('node-fetch');
     
     try {
         // Get earliest available root data date
@@ -156,7 +162,39 @@ async function handleSnapshot(config, dependencies, reqBody) {
         
         if (dateStrings.length === 0) {
             logger.log('WARN', '[Dispatcher] No dates to process for snapshot');
-            return { status: 'OK', processed: 0, skipped: 0 };
+            const finalResult = { status: 'OK', processed: 0, skipped: 0 };
+            
+            // Send callback if provided
+            if (callbackUrl) {
+                logger.log('INFO', `[Dispatcher] 📞 Calling back Workflow at: ${callbackUrl}`);
+                try {
+                    // Add timeout to prevent hanging (30 seconds should be plenty for a callback)
+                    const timeoutPromise = new Promise((_, reject) => 
+                        setTimeout(() => reject(new Error('Callback timeout after 30s')), 30000)
+                    );
+                    
+                    const fetchPromise = directFetch(callbackUrl, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(finalResult)
+                    });
+                    
+                    const response = await Promise.race([fetchPromise, timeoutPromise]);
+                    
+                    if (!response.ok) {
+                        const errorText = await response.text().catch(() => 'Unable to read response');
+                        logger.log('ERROR', `[Dispatcher] Callback returned non-OK status: ${response.status} ${response.statusText}. Response: ${errorText.substring(0, 200)}`);
+                    } else {
+                        logger.log('INFO', `[Dispatcher] ✅ Callback sent successfully (status: ${response.status})`);
+                    }
+                } catch (err) {
+                    logger.log('ERROR', `[Dispatcher] Callback failed: ${err.message}. Stack: ${err.stack?.substring(0, 300)}`);
+                }
+            } else {
+                logger.log('WARN', '[Dispatcher] No callback URL provided, workflow will not be notified');
+            }
+            
+            return finalResult;
         }
         
         logger.log('INFO', `[Dispatcher] 📸 Processing snapshots for ${dateStrings.length} dates from ${dateStrings[0]} to ${dateStrings[dateStrings.length - 1]}`);
@@ -189,7 +227,7 @@ async function handleSnapshot(config, dependencies, reqBody) {
         
         logger.log('INFO', `[Dispatcher] 📸 Snapshot batch complete: ${successful} processed, ${skipped} skipped, ${failed} failed out of ${results.length} total`);
         
-        return { 
+        const finalResult = { 
             status: failed === 0 ? 'OK' : 'PARTIAL', 
             processed: successful,
             skipped: skipped,
@@ -197,10 +235,73 @@ async function handleSnapshot(config, dependencies, reqBody) {
             total: results.length,
             results: results
         };
+        
+        // Send callback to workflow if provided
+        if (callbackUrl) {
+            logger.log('INFO', `[Dispatcher] 📞 Calling back Workflow at: ${callbackUrl}`);
+            try {
+                // Add timeout to prevent hanging (30 seconds should be plenty for a callback)
+                const timeoutPromise = new Promise((_, reject) => 
+                    setTimeout(() => reject(new Error('Callback timeout after 30s')), 30000)
+                );
+                
+                const fetchPromise = directFetch(callbackUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(finalResult)
+                });
+                
+                const response = await Promise.race([fetchPromise, timeoutPromise]);
+                
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => 'Unable to read response');
+                    logger.log('ERROR', `[Dispatcher] Callback returned non-OK status: ${response.status} ${response.statusText}. Response: ${errorText.substring(0, 200)}`);
+                } else {
+                    logger.log('INFO', `[Dispatcher] ✅ Callback sent successfully (status: ${response.status})`);
+                }
+            } catch (err) {
+                logger.log('ERROR', `[Dispatcher] Callback failed: ${err.message}. Stack: ${err.stack?.substring(0, 300)}`);
+            }
+        } else {
+            logger.log('WARN', '[Dispatcher] No callback URL provided, workflow will not be notified');
+        }
+        
+        return finalResult;
     } catch (e) {
         logger.log('ERROR', `[Dispatcher] Snapshot failed: ${e.message}`);
-        // Return error object so workflow can see failure
-        return { status: 'ERROR', error: e.message };
+        const errorResult = { status: 'ERROR', error: e.message };
+        
+        // Notify workflow of failure too, otherwise it hangs!
+        if (callbackUrl) {
+            logger.log('INFO', `[Dispatcher] 📞 Calling back Workflow with error at: ${callbackUrl}`);
+            try {
+                // Add timeout to prevent hanging (30 seconds should be plenty for a callback)
+                const timeoutPromise = new Promise((_, reject) => 
+                    setTimeout(() => reject(new Error('Callback timeout after 30s')), 30000)
+                );
+                
+                const fetchPromise = directFetch(callbackUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(errorResult)
+                });
+                
+                const response = await Promise.race([fetchPromise, timeoutPromise]);
+                
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => 'Unable to read response');
+                    logger.log('ERROR', `[Dispatcher] Error callback returned non-OK status: ${response.status} ${response.statusText}. Response: ${errorText.substring(0, 200)}`);
+                } else {
+                    logger.log('INFO', `[Dispatcher] ✅ Error callback sent successfully (status: ${response.status})`);
+                }
+            } catch (err) {
+                logger.log('ERROR', `[Dispatcher] Error callback failed: ${err.message}. Stack: ${err.stack?.substring(0, 300)}`);
+            }
+        } else {
+            logger.log('WARN', '[Dispatcher] No callback URL provided, workflow will not be notified of error');
+        }
+        
+        return errorResult;
     }
 }
 

package/package.json

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