bulltrackers-module 1.0.21 → 1.0.22

package/functions/computation-system/handler_creator.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Factory function to create the Computation System handler.
+ */
+const { Firestore } = require('@google-cloud/firestore'); // Needed if db is not passed in
+const { logger: defaultLogger } = require("sharedsetup")(__filename); // Use default logger if none provided
+const { runComputationOrchestrator } = require('./helpers/orchestration_helpers');
+
+/**
+ * Creates the Computation System Cloud Function handler (HTTP triggered).
+ * @param {object} config - The Computation System configuration object (can be empty if not needed by the orchestrator directly).
+ * @param {object} [dependencies] - Optional dependencies. If not provided, initializes defaults.
+ * @param {Firestore} [dependencies.firestore] - Firestore client instance.
+ * @param {object} [dependencies.logger] - Logger instance.
+ * @returns {Function} The async Cloud Function handler for HTTP requests.
+ */
+function createComputationSystemHandler(config, dependencies = {}) {
+    // Initialize clients using provided dependencies or defaults
+    const firestore = dependencies.firestore || new Firestore();
+    const logger = dependencies.logger || defaultLogger;
+
+    // Return the actual handler function (Express middleware format)
+    return async (req, res) => {
+        const functionName = 'ComputationSystem'; // Or derive dynamically if needed
+        logger.log('INFO', `[${functionName}] Starting...`);
+        try {
+            // Delegate the core logic to the orchestration helper
+            // Pass the initialized firestore and logger
+            const summary = await runComputationOrchestrator(firestore, logger);
+
+            logger.log('SUCCESS', `[${functionName}] Done.`);
+            // Send success response if headers not already sent
+            if (!res.headersSent) {
+                res.status(200).send({ message: 'Computation complete', summary });
+            }
+        } catch (error) {
+            logger.log('ERROR', `[${functionName}] Failed.`, { errorMessage: error.message, errorStack: error.stack });
+            // Send error response if headers not already sent
+            if (!res.headersSent) {
+                res.status(500).send({ message: 'Computation Error', error: error.message });
+            }
+            // Optional: Re-throw if you want Cloud Functions/Run to explicitly log the failure higher up
+            // throw error;
+        }
+    };
+}
+
+module.exports = {
+    createComputationSystemHandler,
+};

package/functions/computation-system/index.js

@@ -1,9 +1,11 @@
 /**
- * @fileoverview Exports the computation system's main logic.
+ * @fileoverview Exports the computation system's main logic and handler creator.
  */
 
 const { runComputationOrchestrator } = require('./helpers/orchestration_helpers.js');
+const { createComputationSystemHandler } = require('./handler_creator.js'); // <-- Import the new factory
 
 module.exports = {
   runComputationOrchestrator,
+  createComputationSystemHandler, // <-- Export the factory
 };

package/functions/task-engine/handler_creator.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Factory function to create the Task Engine handler.
+ */
+const { Firestore } = require('@google-cloud/firestore'); // Needed if db is not passed in
+const { PubSub } = require('@google-cloud/pubsub'); // Needed if pubsub is not passed in
+const { logger: defaultLogger } = require("sharedsetup")(__filename); // Use default logger if none provided
+const { core } = require('../../'); // Access core utilities like managers
+const TaskEngineHelpers = require('./helpers');
+const TaskEngineUtils = require('./utils');
+
+/**
+ * Creates the Task Engine Cloud Function handler.
+ * @param {object} config - The Task Engine configuration object (e.g., cfg.taskEngine).
+ * @param {object} [dependencies] - Optional dependencies. If not provided, initializes defaults.
+ * @param {Firestore} [dependencies.firestore] - Firestore client instance.
+ * @param {PubSub} [dependencies.pubsub] - PubSub client instance.
+ * @param {object} [dependencies.logger] - Logger instance.
+ * @returns {Function} The async Cloud Function handler for Pub/Sub messages.
+ */
+function createTaskEngineHandler(config, dependencies = {}) {
+    // Initialize clients using provided dependencies or defaults
+    const firestore = dependencies.firestore || new Firestore();
+    const pubsub = dependencies.pubsub || new PubSub();
+    const logger = dependencies.logger || defaultLogger; // Use provided or default logger
+
+    // Initialize managers and batch manager within this scope
+    const headerManager = new core.utils.IntelligentHeaderManager(firestore, logger, config);
+    const proxyManager = new core.utils.IntelligentProxyManager(firestore, logger, config);
+    const batchManager = new TaskEngineUtils.FirestoreBatchManager(firestore, headerManager, config); // Pass headerManager
+
+    const CLIENTS = {
+        pubsub,
+        nativeFirestore: firestore, // Pass the initialized Firestore instance
+        headerManager,
+        proxyManager,
+        batchManager
+    };
+
+    // Return the actual handler function
+    return async (message) => {
+        // Basic check for message structure (Cloud Functions Pub/Sub trigger)
+        if (!message || !message.data) {
+            logger.log('ERROR', '[TaskEngine Module] Received invalid message structure.', { message });
+            // Acknowledge Pub/Sub by not throwing, but log error
+            return;
+        }
+
+        let task;
+        try {
+            // Decode the message
+            task = JSON.parse(Buffer.from(message.data, 'base64').toString('utf-8'));
+        } catch (e) {
+            logger.log('ERROR', '[TaskEngine Module] Failed to parse Pub/Sub message data.', { error: e.message, data: message.data });
+            // Acknowledge Pub/Sub by not throwing
+            return;
+        }
+
+        // Generate a unique ID for logging this specific task execution
+        const taskId = `${task.type || 'unknown'}-${task.userType || 'unknown'}-${task.userId || task.cids?.[0] || 'batch'}-${Date.now()}`;
+        logger.log('INFO', `[TaskEngine/${taskId}] Received.`);
+
+        try {
+            // Optional: Random delay
+            await new Promise(resolve => setTimeout(resolve, Math.random() * 500 + 250));
+
+            // Determine the correct handler function based on task type
+            const handlerFunction = {
+                discover: TaskEngineHelpers.handleDiscover,
+                verify: TaskEngineHelpers.handleVerify,
+                update: TaskEngineHelpers.handleUpdate
+            }[task.type];
+
+            // Execute the handler or log an error if the type is unknown
+            if (handlerFunction) {
+                await handlerFunction(task, taskId, CLIENTS, config); // Pass CLIENTS and config
+                logger.log('SUCCESS', `[TaskEngine/${taskId}] Done.`);
+            } else {
+                logger.log('ERROR', `[TaskEngine/${taskId}] Unknown task type received: ${task.type}`);
+                // Acknowledge Pub/Sub by not throwing
+            }
+        } catch (error) {
+            // Log the error but crucially *do not re-throw* if you want Pub/Sub to ack the message
+            // Only re-throw if you want Pub/Sub to attempt redelivery based on its settings.
+            // Your existing logic logs but then re-throws - decide if that's the desired behavior.
+            logger.log('ERROR', `[TaskEngine/${taskId}] Failed.`, { errorMessage: error.message, errorStack: error.stack });
+            // throw error; // Optional: Uncomment if you want Pub/Sub to retry
+        } finally {
+             // Ensure batches are flushed eventually, though the batch manager handles timed flushes.
+             // A final flush here might be redundant if the instance stays alive, but could be useful
+             // if the instance might terminate immediately after processing.
+             try {
+                // Consider if flushing on every single message is desired vs relying on timed flush
+                // await batchManager.flushBatches();
+             } catch (flushError) {
+                 logger.log('ERROR', `[TaskEngine/${taskId}] Error during final flush attempt.`, { error: flushError.message });
+             }
+        }
+    };
+}
+
+module.exports = {
+    createTaskEngineHandler,
+};

package/functions/task-engine/index.js

@@ -4,8 +4,10 @@
 
 const helpers = require('./helpers');
 const utils = require('./utils');
+const { createTaskEngineHandler } = require('./handler_creator'); // <-- Import the new factory
 
 module.exports = {
   helpers,
   utils,
+  createTaskEngineHandler, // <-- Export the factory
 };

package/package.json

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