bulltrackers-module 1.0.151 → 1.0.153

package/functions/generic-api/index.js

@@ -10,13 +10,7 @@
 const express = require('express');
 const cors = require('cors');
 const { FieldPath } = require('@google-cloud/firestore'); 
-const { 
-    buildCalculationMap, 
-    createApiHandler, 
-    getComputationStructure,
-    createManifestHandler, // <-- IMPORT NEW HANDLER
-    getDynamicSchema      // <-- This helper's behavior has changed
-} = require('./helpers/api_helpers.js');
+const { buildCalculationMap, createApiHandler, getComputationStructure,createManifestHandler, getDynamicSchema } = require('./helpers/api_helpers.js');
 
 /**
  * --- NEW: In-Memory Cache Handler ---
@@ -27,60 +21,29 @@ const {
  * @returns {function} The new (req, res) handler with caching logic.
  */
 const createCacheHandler = (handler, { logger }) => {
-    // 1. Define the cache *outside* the handler so it persists
+    // 1. Cache
     const CACHE = {};
-    const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minute cache
-
+    const CACHE_TTL_MS = 10 * 60 * 1000; 
     // 2. Return the new handler
-    return async (req, res) => {
-        const cacheKey = req.url; // Use the full URL (e.g., "/?computation=foo") as the key
-        const now = Date.now();
-
-        // 3. --- Cache HIT ---
-        if (CACHE[cacheKey] && (now - CACHE[cacheKey].timestamp) < CACHE_TTL_MS) {
-            logger.log('INFO', `[API] Cache HIT for ${cacheKey}`);
-            // Send cached status and data
-            return res.status(CACHE[cacheKey].status).send(CACHE[cacheKey].data);
-        }
-
-        // 4. --- Cache MISS ---
-        logger.log('INFO', `[API] Cache MISS for ${cacheKey}`);
-
-        // We need to capture the response from the original handler.
-        // To do this, we "monkey-patch" res.send and res.status.
-        const originalSend = res.send;
-        const originalStatus = res.status;
-
-        let capturedData = null;
-        let capturedStatus = 200; // Default
-
-        // Create a new status function
-        res.status = (statusCode) => {
-            capturedStatus = statusCode;
-            // Call the original status function
-            return originalStatus.call(res, statusCode);
-        };
-
-        // Create a new send function
-        res.send = (data) => {
-            capturedData = data;
-            // Call the original send function
-            return originalSend.call(res, data);
-        };
-
-        // 5. Call the original handler (which will now use our patched functions)
-        await handler(req, res);
-
-        // 6. If the response was successful, cache it
-        if (capturedStatus === 200 && capturedData) {
-            logger.log('INFO', `[API] Caching new entry for ${cacheKey}`);
-            CACHE[cacheKey] = {
-                data: capturedData,
-                status: capturedStatus,
-                timestamp: now
-            };
-        }
-    };
+    return async (req, res) => { const cacheKey = req.url;  const now = Date.now();
+    // 3. --- Cache HIT ---
+    if (CACHE[cacheKey] && (now - CACHE[cacheKey].timestamp) < CACHE_TTL_MS) {
+    logger.log('INFO', `[API] Cache HIT for ${cacheKey}`);
+    return res.status(CACHE[cacheKey].status).send(CACHE[cacheKey].data); }
+    // 4. --- Cache MISS ---
+    logger.log('INFO', `[API] Cache MISS for ${cacheKey}`);
+    const originalSend = res.send;
+    const originalStatus = res.status;
+    let capturedData = null;
+    let capturedStatus = 200;
+    res.status = (statusCode) => { capturedStatus = statusCode; return originalStatus.call(res, statusCode); };
+    res.send = (data) => { capturedData = data; return originalSend.call(res, data); };
+    // 5. Call the original handler (which will now use our patched functions)
+    await handler(req, res);
+    // 6. If the response was successful, cache it
+    if (capturedStatus === 200 && capturedData) {
+    logger.log('INFO', `[API] Caching new entry for ${cacheKey}`);
+    CACHE[cacheKey] = { data: capturedData, status: capturedStatus, timestamp: now }; } };
 };
 
 
@@ -94,8 +57,8 @@ const createCacheHandler = (handler, { logger }) => {
  */
 function createApiApp(config, dependencies, unifiedCalculations) {
     const app = express();
-    const { logger, db } = dependencies; 
-
+    const { logger, db } = dependencies;
+    
     // --- Pre-compute Calculation Map (now includes classes) ---
     const calcMap = buildCalculationMap(unifiedCalculations);
 
@@ -104,126 +67,58 @@ function createApiApp(config, dependencies, unifiedCalculations) {
     app.use(express.json());
 
     // --- Main API Endpoint ---
-    // MODIFIED: We now wrap the original handler with the cache handler.
     const originalApiHandler = createApiHandler(config, dependencies, calcMap);
     const cachedApiHandler = createCacheHandler(originalApiHandler, dependencies);
-    app.get('/', cachedApiHandler); // <-- Use the new caching handler
+    app.get('/', cachedApiHandler); 
 
     // --- Health Check Endpoint ---
-    app.get('/health', (req, res) => {
-        res.status(200).send('OK');
-    });
+    app.get('/health', (req, res) => { res.status(200).send('OK'); });
 
     // --- Debug Endpoint to list all computation keys ---
     app.get('/list-computations', (req, res) => {
-        try {
-            const computationKeys = Object.keys(calcMap);
-            res.status(200).send({
-                status: 'success',
-                count: computationKeys.length,
-                computations: computationKeys.sort(),
-            });
-        } catch (error) {
-            logger.log('ERROR', 'API /list-computations failed.', { errorMessage: error.message });
-            res.status(500).send({ status: 'error', message: 'An internal error occurred.' });
-        }
-    });
+        try { const computationKeys = Object.keys(calcMap); 
+        res.status(200).send({ status: 'success', count: computationKeys.length, computations: computationKeys.sort(), });
+        } catch (error) { logger.log('ERROR', 'API /list-computations failed.', { errorMessage: error.message });
+        res.status(500).send({ status: 'error', message: 'An internal error occurred.' }); } });
 
     // --- Debug Endpoint to get *stored* structure from Firestore ---
     app.get('/structure/:computationName', async (req, res) => {
         const { computationName } = req.params;
         const result = await getComputationStructure(computationName, calcMap, config, dependencies);
-        if (result.status === 'error') {
-            const statusCode = result.message.includes('not found') ? 404 : 500;
-            return res.status(statusCode).send(result);
-        }
-        res.status(200).send(result);
-    });
-
-    /**
-     * ---!!!--- REPLACED SECTION ---!!!---
-     * This route now uses the createManifestHandler to serve the
-     * pre-generated schemas from Firestore.
-     */
+        if (result.status === 'error') { const statusCode = result.message.includes('not found') ? 404 : 500;
+        return res.status(statusCode).send(result); }
+        res.status(200).send(result); });
     app.get('/manifest', createManifestHandler(config, dependencies, calcMap));
-    
-    
-    /**
-     * ---!!!--- REPLACED SECTION ---!!!---
-     * This endpoint now reads the *static* getSchema() method from a class
-     * and stores that in Firestore. It no longer does runtime inference.
-     */
     app.post('/manifest/generate/:computationName', async (req, res) => {
         const { computationName } = req.params;
         logger.log('INFO', `Manual static schema generation requested for: ${computationName}`);
-        
+
         try {
             // 1. Find the calculation class from the calcMap
             const calcInfo = calcMap[computationName];
-            
-            if (!calcInfo || !calcInfo.class) {
-                return res.status(404).send({
-                    status: 'error',
-                    message: `Computation '${computationName}' not found or has no class in calculation map.`
-                });
-            }
-            
+            if (!calcInfo || !calcInfo.class) { return res.status(404).send({ status: 'error', message: `Computation '${computationName}' not found or has no class in calculation map.` }); }
             const targetCalcClass = calcInfo.class;
             const targetCategory = calcInfo.category;
 
             // 2. Use the getDynamicSchema helper (which now just reads the static method)
             const schemaStructure = await getDynamicSchema(targetCalcClass, computationName);
+            if (schemaStructure.ERROR) { return res.status(400).send({ status: 'error', message: `Failed to get static schema: ${schemaStructure.ERROR}` }); }
             
-            if (schemaStructure.ERROR) {
-                return res.status(400).send({
-                    status: 'error',
-                    message: `Failed to get static schema: ${schemaStructure.ERROR}`
-                });
-            }
-
             // 3. Import the new batchStoreSchemas utility
-            const { batchStoreSchemas } = require('../computation-system/utils/schema_capture');
+            const { batchStoreSchemas } = require('../computation-system/utils/schema_capture.js');
 
             // 4. Get metadata (as much as we can from the class)
-            const metadata = {
-                isHistorical: !!(targetCalcClass.toString().includes('yesterdayPortfolio')),
-                dependencies: (typeof targetCalcClass.getDependencies === 'function') ? targetCalcClass.getDependencies() : [],
-                rootDataDependencies: [], // Cannot be known here
-                pass: 'unknown', // Cannot be known here
-                type: (targetCategory === 'meta' || targetCategory === 'socialPosts') ? targetCategory : 'standard',
-                note: "Manually generated via API"
-            };
+            const metadata = { isHistorical: !!(targetCalcClass.toString().includes('yesterdayPortfolio')), dependencies: (typeof targetCalcClass.getDependencies === 'function') ? targetCalcClass.getDependencies() : [], rootDataDependencies: [],  pass: 'unknown',  type: (targetCategory === 'meta' || targetCategory === 'socialPosts') ? targetCategory : 'standard', note: "Manually generated via API" };
 
             // 5. Store the schema in Firestore
-            await batchStoreSchemas(
-                dependencies,
-                config,
-                [{
-                    name: computationName,
-                    category: targetCategory,
-                    schema: schemaStructure, // Pass the static schema
-                    metadata: metadata
-                }]
-            );
-            
+            await batchStoreSchemas( dependencies, config, [{ name: computationName, category: targetCategory, schema: schemaStructure, metadata: metadata }] );
+
             // 6. Respond with the schema
-            res.status(200).send({
-                status: 'success',
-                message: `Static schema read and stored for ${computationName}`,
-                computation: computationName,
-                category: targetCategory,
-                schema: schemaStructure
-            });
-            
+            res.status(200).send({ status: 'success', message: `Static schema read and stored for ${computationName}`, computation: computationName, category: targetCategory, schema: schemaStructure });
+
         } catch (error) {
-            logger.log('ERROR', `Failed to generate schema for ${computationName}`, {
-                errorMessage: error.message,
-                stack: error.stack
-            });
-            res.status(5.00).send({
-                status: 'error',
-                message: `Failed to generate/store schema: ${error.message}`
-            });
+            logger.log('ERROR', `Failed to generate schema for ${computationName}`, { errorMessage: error.message, stack: error.stack });
+            res.status(5.00).send({ status: 'error', message: `Failed to generate/store schema: ${error.message}` });
         }
     });
 
@@ -233,49 +128,15 @@ function createApiApp(config, dependencies, unifiedCalculations) {
      */
     app.get('/manifest/:computationName', async (req, res) => {
         const { computationName } = req.params;
-        
         try {
             const schemaCollection = config.schemaCollection || 'computation_schemas';
             const schemaDoc = await db.collection(schemaCollection).doc(computationName).get();
-            
-            if (!schemaDoc.exists) {
-                return res.status(4404).send({
-                    status: 'error',
-                    message: `Schema not found for computation: ${computationName}`,
-                    hint: 'Try running the computation system or use POST /manifest/generate/:computationName'
-                });
-            }
-            
-            const data = schemaDoc.data();
-            
-            // --- Use the same response structure as /manifest ---
-            res.status(200).send({
-                status: 'success',
-                computation: computationName,
-                category: data.category,
-                structure: data.schema,
-                metadata: data.metadata || {},
-                lastUpdated: data.lastUpdated
-            });
-            
-        } catch (error) {
-            logger.log('ERROR', `Failed to fetch schema for ${computationName}`, {
-                errorMessage: error.message
-            });
-            res.status(500).send({
-                status: 'error',
-                message: 'An internal error occurred.'
-            });
-        }
-    });
-
-    // --- THIS MUST BE THE LAST LINE OF THE FUNCTION ---
+            if (!schemaDoc.exists) { return res.status(4404).send({ status: 'error', message: `Schema not found for computation: ${computationName}`, hint: 'Try running the computation system or use POST /manifest/generate/:computationName' }); }
+            const data = schemaDoc.data();            
+            res.status(200).send({ status: 'success', computation: computationName, category: data.category, structure: data.schema, metadata: data.metadata || {}, lastUpdated: data.lastUpdated });
+        } catch (error) { logger.log('ERROR', `Failed to fetch schema for ${computationName}`, { errorMessage: error.message }); res.status(500).send({ status: 'error', message: 'An internal error occurred.' }); }});
     return app;
 }
 
 
-module.exports = {
-    createApiApp,
-    // Exporting helpers so they can be part of the pipe.api.helpers object
-    helpers: require('./helpers/api_helpers'), 
-};
+module.exports = { createApiApp, helpers: require('./helpers/api_helpers.js') };

package/functions/invalid-speculator-handler/helpers/handler_helpers.js

@@ -15,61 +15,24 @@ exports.handleInvalidSpeculator = async (message, context, config, dependencies)
     const { db, logger } = dependencies;
     try {
         const { invalidCids } = JSON.parse(Buffer.from(message.data, 'base64').toString());
-
-        if (!invalidCids || invalidCids.length === 0) {
-            logger.log('WARN', 'Received message with no invalid CIDs. Nothing to do.');
-            return;
-        }
-
-        const collectionRef = db.collection(config.invalidSpeculatorsCollectionName); // Use db
+        if (!invalidCids || invalidCids.length === 0) { logger.log('WARN', 'Received message with no invalid CIDs. Nothing to do.'); return; }
+        const collectionRef = db.collection(config.invalidSpeculatorsCollectionName); 
         const maxPerDoc = config.maxInvalidUsersPerDoc;
-
-        const querySnapshot = await collectionRef
-            .where('userCount', '<', maxPerDoc)
-            .limit(10)
-            .get();
-
+        const querySnapshot = await collectionRef .where('userCount', '<', maxPerDoc) .limit(10) .get();
         let targetDocRef;
-
-        if (!querySnapshot.empty) {
-            const randomIndex = Math.floor(Math.random() * querySnapshot.docs.length);
-            targetDocRef = querySnapshot.docs[randomIndex].ref;
-        } else {
-            targetDocRef = collectionRef.doc();
-        }
-
-        // Use db from dependencies
-        await db.runTransaction(async (transaction) => {
-            const doc = await transaction.get(targetDocRef);
-            
+        if (!querySnapshot.empty) { const randomIndex = Math.floor(Math.random() * querySnapshot.docs.length); targetDocRef = querySnapshot.docs[randomIndex].ref;
+        } else { targetDocRef = collectionRef.doc(); }
+        await db.runTransaction(async (transaction) => { const doc = await transaction.get(targetDocRef);
             const updates = {};
             let newUsersCount = 0;
-
-            if (!doc.exists) {
-                updates.userCount = 0;
-            }
-
+            if (!doc.exists) { updates.userCount = 0; }
             for (const cid of invalidCids) {
                 const fieldPath = `users.${cid}`;
-                if (!doc.exists || !doc.data().users || !doc.data().users[cid]) {
-                    updates[fieldPath] = true;
-                    newUsersCount++;
-                }
-            }
-
-            if (newUsersCount > 0) {
-                updates.userCount = FieldValue.increment(newUsersCount);
-                transaction.set(targetDocRef, updates, { merge: true });
-            }
-        });
-
+                if (!doc.exists || !doc.data().users || !doc.data().users[cid]) {updates[fieldPath] = true; newUsersCount++; } }
+            if (newUsersCount > 0) { updates.userCount = FieldValue.increment(newUsersCount); transaction.set(targetDocRef, updates, { merge: true }); } });
         logger.log('SUCCESS', `Successfully stored ${invalidCids.length} invalid speculator IDs in document ${targetDocRef.id}.`);
-
     } catch (error) {
-        logger.log('ERROR', 'FATAL Error in Invalid Speculator Handler', {
-            errorMessage: error.message,
-            errorStack: error.stack
-        });
+        logger.log('ERROR', 'FATAL Error in Invalid Speculator Handler', { errorMessage: error.message, errorStack: error.stack });
         throw error;
     }
 };

package/functions/orchestrator/helpers/discovery_helpers.js

@@ -105,8 +105,4 @@ async function dispatchDiscovery(userType, candidates, config, dependencies) {
         logger.log('SUCCESS', `[Orchestrator Helpers] Dispatched ${totalCidsPublished} CIDs in ${tasks.length} tasks, grouped into ${messagesPublished} Pub/Sub messages for ${userType} discovery.`);
 }
 
-module.exports = {
-  checkDiscoveryNeed,
-  getDiscoveryCandidates,
-  dispatchDiscovery,
-};
+module.exports = { checkDiscoveryNeed, getDiscoveryCandidates, dispatchDiscovery };

package/functions/orchestrator/index.js

@@ -61,9 +61,4 @@ async function runUpdates(userType, updateConfig, globalConfig, deps) {
     logger.log('SUCCESS', `[Orchestrator] Dispatched update tasks for ${userType}.`);
 }
 
-module.exports = {
-    runDiscoveryOrchestrator,
-    runUpdateOrchestrator,
-    runDiscovery,
-    runUpdates
-};
+module.exports = { runDiscoveryOrchestrator, runUpdateOrchestrator, runDiscovery, runUpdates };

package/functions/price-backfill/helpers/handler_helpers.js

@@ -4,15 +4,10 @@
  * candle API into the new sharded `asset_prices` collection.
  */
 
-const { FieldValue } = require('@google-cloud/firestore'); // Todo inject this
-
-const pLimit = require('p-limit'); // TODO inject this
-
-// How many tickers to fetch in parallel
+const { FieldValue } = require('@google-cloud/firestore');
+const pLimit = require('p-limit'); 
 const CONCURRENT_REQUESTS = 10;
-// How many days of history to fetch
 const DAYS_TO_FETCH = 365;
-// How many tickers to group into one Firestore document
 const SHARD_SIZE = 40;
 
 /**
@@ -20,97 +15,46 @@ const SHARD_SIZE = 40;
  * @param {object} config - Configuration object.
  * @param {object} dependencies - Contains db, logger, headerManager, proxyManager, calculationUtils.
  */
-// --- MODIFIED: Removed calculationUtils, as it's in dependencies ---
 exports.runBackfillAssetPrices = async (config, dependencies) => {
     const { db, logger, headerManager, proxyManager, calculationUtils } = dependencies;
-    const { loadInstrumentMappings } = calculationUtils; // <-- Get function from dependencies
-    // --- END MODIFIED ---
-    
+    const { loadInstrumentMappings } = calculationUtils; 
     logger.log('INFO', '[PriceBackfill] Starting historical price backfill...');
-    
     let mappings;
     try {
-        // --- MODIFIED: Use the injected utils ---
         mappings = await loadInstrumentMappings();
-        // --- END MODIFIED ---
-        if (!mappings || !mappings.instrumentToTicker) {
-            throw new Error("Failed to load instrument mappings.");
-        }
-    } catch (e) {
-        logger.log('ERROR', '[PriceBackfill] Could not load instrument mappings.', { err: e.message });
-        return;
-    }
-
+        if (!mappings || !mappings.instrumentToTicker) { throw new Error("Failed to load instrument mappings."); }
+    } catch (e) { logger.log('ERROR', '[PriceBackfill] Could not load instrument mappings.', { err: e.message }); return; }
     const instrumentIds = Object.keys(mappings.instrumentToTicker);
     logger.log('INFO', `[PriceBackfill] Found ${instrumentIds.length} instruments to backfill.`);
-
     const limit = pLimit(CONCURRENT_REQUESTS);
     let successCount = 0;
     let errorCount = 0;
-
     const promises = instrumentIds.map(instrumentId => {
         return limit(async () => {
             try {
                 const ticker = mappings.instrumentToTicker[instrumentId] || `unknown_${instrumentId}`;
-                const url = `https://candle.etoro.com/candles/asc.json/OneDay/${DAYS_TO_FETCH}/${instrumentId}`; //TODO implement config value
-                
+                const url = `https://candle.etoro.com/candles/asc.json/OneDay/${DAYS_TO_FETCH}/${instrumentId}`; 
                 const selectedHeader = await headerManager.selectHeader();
                 let wasSuccess = false;
-
-                const response = await proxyManager.fetch(url, {
-                    headers: selectedHeader.header,
-                    timeout: 20000
-                });
-
-                if (!response.ok) {
-                    throw new Error(`API error ${response.status} for instrument ${instrumentId}`);
-                }
+                const response = await proxyManager.fetch(url, { headers: selectedHeader.header, timeout: 20000 });
+                if (!response.ok) { throw new Error(`API error ${response.status} for instrument ${instrumentId}`); }
                 wasSuccess = true;
                 headerManager.updatePerformance(selectedHeader.id, wasSuccess);
-
                 const data = await response.json();
                 const candles = data?.Candles?.[0]?.Candles;
-
-                if (!Array.isArray(candles) || candles.length === 0) {
-                    logger.log('WARN', `[PriceBackfill] No candle data returned for ${ticker} (${instrumentId})`);
-                    return;
-                }
-
-                // Format data as a map
+                if (!Array.isArray(candles) || candles.length === 0) { logger.log('WARN', `[PriceBackfill] No candle data returned for ${ticker} (${instrumentId})`); return; }
                 const prices = {};
-                for (const candle of candles) {
-                    const dateKey = candle.FromDate.substring(0, 10);
-                    prices[dateKey] = candle.Close;
-                }
-
-                // Determine shard ID
+                for (const candle of candles) { const dateKey = candle.FromDate.substring(0, 10); prices[dateKey] = candle.Close; }
                 const shardId = `shard_${parseInt(instrumentId, 10) % SHARD_SIZE}`;
-                const docRef = db.collection('asset_prices').doc(shardId); // TODO implement config value
-
-                const payload = {
-                    [instrumentId]: {
-                        ticker: ticker,
-                        prices: prices,
-                        lastUpdated: FieldValue.serverTimestamp()
-                    }
-                };
-                
-                // Write to Firestore
+                const docRef = db.collection('asset_prices').doc(shardId); 
+                const payload = { [instrumentId]: { ticker: ticker, prices: prices, lastUpdated: FieldValue.serverTimestamp() } };
                 await docRef.set(payload, { merge: true });
                 logger.log('TRACE', `[PriceBackfill] Successfully stored data for ${ticker} (${instrumentId}) in ${shardId}`);
                 successCount++;
-
             } catch (err) {
                 logger.log('ERROR', `[PriceBackfill] Failed to process instrument ${instrumentId}`, { err: err.message });
-                errorCount++;
-            }
-        });
-    });
-
+                errorCount++; } }); });
     await Promise.all(promises);
-
-    // Flush any remaining header updates
     await headerManager.flushPerformanceUpdates();
-
     logger.log('SUCCESS', `[PriceBackfill] Backfill complete. Success: ${successCount}, Failed: ${errorCount}`);
 };

package/functions/social-orchestrator/helpers/orchestrator_helpers.js

@@ -13,50 +13,18 @@
 exports.runSocialOrchestrator = async (config, dependencies) => {
     const { logger, pubsubUtils } = dependencies;
     logger.log('INFO', '[SocialOrchestrator] Starting social post fetching orchestration...');
-
-    // Validate configuration
-    if (!config.targetTickerIds || !Array.isArray(config.targetTickerIds) || !config.socialFetchTaskTopicName || !config.socialFetchTimeWindowHours) {
-        logger.log('ERROR', '[SocialOrchestrator] Missing required configuration: targetTickerIds (array), socialFetchTaskTopicName, or socialFetchTimeWindowHours.');
-        throw new Error('Missing required configuration for Social Orchestrator.');
-    }
-
+    if (!config.targetTickerIds || !Array.isArray(config.targetTickerIds) || !config.socialFetchTaskTopicName || !config.socialFetchTimeWindowHours) { logger.log('ERROR', '[SocialOrchestrator] Missing required configuration: targetTickerIds (array), socialFetchTaskTopicName, or socialFetchTimeWindowHours.'); throw new Error('Missing required configuration for Social Orchestrator.'); }
     try {
         const tasks = [];
         const { targetTickerIds, socialFetchTimeWindowHours } = config;
-        
-        // Calculate the 'since' timestamp
         const sinceTimestamp = new Date();
         sinceTimestamp.setHours(sinceTimestamp.getHours() - socialFetchTimeWindowHours);
-        
-        // Add a 15-minute buffer to ensure overlap
         sinceTimestamp.setMinutes(sinceTimestamp.getMinutes() - 15); 
-        
         const sinceISO = sinceTimestamp.toISOString();
-
-        for (const tickerId of targetTickerIds) {
-            tasks.push({
-                tickerId: String(tickerId), // Ensure it's a string
-                since: sinceISO
-            });
-        }
-
-        if (tasks.length === 0) {
-            logger.log('WARN', '[SocialOrchestrator] No target tickers found to process.');
-            return { success: true, message: "No target tickers configured." };
-        }
-
-        // Use pubsubUtils to batch publish all ticker tasks
-        await pubsubUtils.batchPublishTasks(dependencies, {
-            topicName: config.socialFetchTaskTopicName,
-            tasks: tasks,
-            taskType: 'social-fetch-task'
-        });
-
+        for (const tickerId of targetTickerIds) { tasks.push({ tickerId: String(tickerId),  since: sinceISO }); }
+        if (tasks.length === 0) { logger.log('WARN', '[SocialOrchestrator] No target tickers found to process.'); return { success: true, message: "No target tickers configured." }; }
+        await pubsubUtils.batchPublishTasks(dependencies, { topicName: config.socialFetchTaskTopicName, tasks: tasks, taskType: 'social-fetch-task' });
         logger.log('SUCCESS', `[SocialOrchestrator] Successfully published ${tasks.length} social fetch tasks for window >= ${sinceISO}.`);
         return { success: true, tasksQueued: tasks.length };
-
-    } catch (error) {
-        logger.log('ERROR', '[SocialOrchestrator] Fatal error during orchestration.', { errorMessage: error.message, errorStack: error.stack });
-        throw error;
-    }
+    } catch (error) { logger.log('ERROR', '[SocialOrchestrator] Fatal error during orchestration.', { errorMessage: error.message, errorStack: error.stack }); throw error; }
 };