bulltrackers-module 1.0.94 → 1.0.96

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

@@ -2,6 +2,7 @@
  * @fileoverview Main pipe: pipe.computationSystem.runOrchestration
  * REFACTORED: Now stateless and receives dependencies.
  * All internal helpers now receive (config, dependencies) as well.
+ * UPDATED: Added Pass 4 for 'backtest' calculations.
  */
 
 const { FieldPath } = require('@google-cloud/firestore');
@@ -41,13 +42,15 @@ async function runComputationOrchestrator(config, dependencies, calculations) {
         historicalCalculations,
         dailyCalculations,
         metaCalculations,
+        backtestCalculations, // <-- ADD THIS
         HISTORICAL_CALC_NAMES,
-        META_CALC_NAMES
+        META_CALC_NAMES,
+        BACKTEST_CALC_NAMES   // <-- ADD THIS
     } = categorizeCalculations(calculations);
     // --- END NEW ---
 
-    // --- MODIFIED: Add pass3_results to summary ---
-    const summary = { pass1_results: [], pass2_results: [], pass3_results: [] };
+    // --- MODIFIED: Add pass4_results to summary ---
+    const summary = { pass1_results: [], pass2_results: [], pass3_results: [], pass4_results: [] };
     // --- END MODIFIED ---
     const yesterday = new Date();
     yesterday.setUTCDate(yesterday.getUTCDate() - 1);
@@ -72,13 +75,20 @@ async function runComputationOrchestrator(config, dependencies, calculations) {
         Object.keys(calcs).map(name => ({ category: cat, calcName: name }))
     );
     // --- END NEW ---
+    
+    // --- NEW: Create master list for backtests ---
+    const masterBacktestList = Object.entries(backtestCalculations).flatMap(([cat, calcs]) => // <-- ADD THIS
+        Object.keys(calcs).map(name => ({ category: cat, calcName: name }))
+    );
+    // --- END NEW ---
 
     const masterFullList = [
         ...masterHistoricalList, 
         ...masterDailyList, 
         ...masterInsightsList,
         ...masterSocialPostList,
-        ...masterMetaList // <-- NEW
+        ...masterMetaList, // <-- NEW
+        ...masterBacktestList // <-- ADD THIS
     ];
 
     // Pass dependencies to sub-pipe
@@ -121,7 +131,8 @@ async function runComputationOrchestrator(config, dependencies, calculations) {
         if (!/^\d{4}-\d{2}-\d{2}$/.test(doc.id)) return;
         const data = doc.data();
         const missingCalcs = masterFullList.filter(({ category, calcName }) => 
-            !META_CALC_NAMES.has(calcName) && // <-- Exclude meta calcs from Pass 2
+            !META_CALC_NAMES.has(calcName) && // <-- Exclude meta calcs
+            !BACKTEST_CALC_NAMES.has(calcName) && // <-- Exclude backtest calcs
             !data?.[category]?.[calcName]
         );
 
@@ -204,6 +215,43 @@ async function runComputationOrchestrator(config, dependencies, calculations) {
     summary.pass3_results = pass3Results.map((r, i) => r.status === 'fulfilled' ? r.value : { success: false, date: pass3Jobs[i].date, error: r.reason?.message });
     // --- END NEW PASS 3 ---
 
+    // --- NEW: PASS 4 (Backtests) ---
+    // This pass runs *after* Pass 3, checking for missing *backtest* calculations.
+    const pass4Jobs = [];
+    // We can re-use the final doc list from the end of Pass 3
+    finalInsightDocs.forEach(doc => {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(doc.id)) return;
+        if (!allExpectedDates.includes(doc.id)) return;
+
+        const data = doc.data();
+        const missingBacktestCalcs = masterBacktestList.filter(({ category, calcName }) => 
+            !data?.[category]?.[calcName]
+        );
+
+        if (missingBacktestCalcs.length > 0) {
+            pass4Jobs.push({ date: doc.id, missing: missingBacktestCalcs });
+        }
+    });
+
+    logger.log('INFO', `[Orchestrator] Pass 4: Found ${pass4Jobs.length} dates to process for backtest-calculations.`);
+    
+    // We can REUSE runMetaComputation because it has the same signature
+    const pass4Results = await processJobsInParallel(
+        pass4Jobs,
+        (date, missing) => runMetaComputation( // Re-using this handler
+            date, 
+            missing, 
+            'Pass 4 (Backtest)', 
+            backtestCalculations, // Pass the backtest calcs package
+            config, 
+            dependencies
+        ),
+        'Pass 4',
+        config
+    );
+    summary.pass4_results = pass4Results.map((r, i) => r.status === 'fulfilled' ? r.value : { success: false, date: pass4Jobs[i].date, error: r.reason?.message });
+    // --- END NEW PASS 4 ---
+
 
     logger.log('INFO', '[Orchestrator] Computation orchestration finished.');
     return summary;
@@ -260,7 +308,9 @@ async function streamAndProcess(
         instrumentMappings: instrumentToTicker, 
         sectorMapping: instrumentToSector,
         todayDateStr: dateStr,
-        yesterdayDateStr: yesterdayStr
+        yesterdayDateStr: yesterdayStr,
+        dependencies: dependencies, // <-- Pass dependencies into context for meta-calcs
+        config: config // <-- Pass config into context for meta-calcs
     };
 
     const batchSize = config.partRefBatchSize || 10;
@@ -474,26 +524,50 @@ async function runUnifiedComputation(dateToProcess, calculationsToRun, passName,
                 const summaryData = {};
 
                 if (result && Object.keys(result).length > 0) {
-                    if (result.sharded_user_profitability) {
-                        for (const shardId in result.sharded_user_profitability) {
-                             const shardData = result.sharded_user_profitability[shardId];
-                             if (shardData && Object.keys(shardData).length > 0) {
-                                 const shardRef = db.collection(config.shardedProfitabilityCollection).doc(shardId); // Use db
-                                 pendingWrites.push({ ref: shardRef, data: { profits: shardData } });
-                             }
+                    // --- SPECIAL HANDLING FOR SHARDED CALCS ---
+                    // (This is a bit hardcoded, but necessary for sharded outputs)
+                    let isSharded = false;
+                    const shardedCollections = {
+                        'sharded_user_profile': config.shardedUserProfileCollection,
+                        'sharded_user_profitability': config.shardedProfitabilityCollection
+                    };
+
+                    for (const resultKey in shardedCollections) {
+                        if (result[resultKey]) {
+                            isSharded = true;
+                            const shardCollectionName = shardedCollections[resultKey];
+                            const shardedData = result[resultKey];
+                            
+                            for (const shardId in shardedData) {
+                                const shardDocData = shardedData[shardId];
+                                if (shardDocData && Object.keys(shardDocData).length > 0) {
+                                    const shardRef = db.collection(shardCollectionName).doc(shardId);
+                                    pendingWrites.push({ ref: shardRef, data: shardDocData });
+                                }
+                            }
+                            // Store the *other* results from the calc, if any
+                            const { [resultKey]: _, ...otherResults } = result;
+                            if (Object.keys(otherResults).length > 0) {
+                                const computationDocRef = resultsCollectionRef.doc(category)
+                                    .collection(config.computationsSubcollection)
+                                    .doc(calcName);
+                                pendingWrites.push({ ref: computationDocRef, data: otherResults });
+                            }
                         }
-                         if (!summaryData[category]) summaryData[category] = {};
-                         summaryData[category][calcName] = true;
+                    }
+                    // --- END SPECIAL HANDLING ---
 
-                    } else {
+                    if (!isSharded) {
                         const computationDocRef = resultsCollectionRef.doc(category)
                                                           .collection(config.computationsSubcollection)
                                                           .doc(calcName);
                         pendingWrites.push({ ref: computationDocRef, data: result });
-                        if (!summaryData[category]) summaryData[category] = {};
-                        summaryData[category][calcName] = true;
                     }
 
+                    // Add summary flag
+                    if (!summaryData[category]) summaryData[category] = {};
+                    summaryData[category][calcName] = true;
+
                      if (Object.keys(summaryData).length > 0) {
                         const topLevelDocRef = db.collection(config.resultsCollection).doc(dateStr); // Use db
                         pendingWrites.push({ ref: topLevelDocRef, data: summaryData });
@@ -531,14 +605,14 @@ async function runUnifiedComputation(dateToProcess, calculationsToRun, passName,
 
 // --- NEW: Add the handler for meta-calculations ---
 /**
- * Internal sub-pipe: Runs "meta" computations for a single date.
+ * Internal sub-pipe: Runs "meta" or "backtest" computations for a single date.
  * These calculations do NOT stream user data, but rather use the
  * special `process(dateStr, dependencies, config)` signature.
  */
 async function runMetaComputation(dateToProcess, calculationsToRun, passName, sourcePackage, config, dependencies) {
     const { db, logger } = dependencies;
     const dateStr = dateToProcess.toISOString().slice(0, 10);
-    logger.log('INFO', `[${passName}] Starting run for ${dateStr} with ${calculationsToRun.length} meta-calcs.`);
+    logger.log('INFO', `[${passName}] Starting run for ${dateStr} with ${calculationsToRun.length} calcs.`);
 
     try {
         const state = initializeCalculators(calculationsToRun, sourcePackage, logger);
@@ -561,7 +635,7 @@ async function runMetaComputation(dateToProcess, calculationsToRun, passName, so
 
                 // Check if the result is valid
                 if (result && Object.keys(result).length > 0) {
-                    // Meta calcs are not expected to be sharded, but we handle the standard case
+                    // Meta calcs are not expected to be sharded
                     const computationDocRef = resultsCollectionRef.doc(category)
                                                       .collection(config.computationsSubcollection)
                                                       .doc(calcName);

package/functions/computation-system/utils/utils.js

@@ -21,10 +21,12 @@ const { FieldValue, FieldPath } = require('@google-cloud/firestore');
 function categorizeCalculations(calculations) {
     const HISTORICAL_CALC_NAMES = new Set();
     const META_CALC_NAMES = new Set();
+    const BACKTEST_CALC_NAMES = new Set(); // <-- ADD THIS
 
     const historicalCalculations = {};
     const dailyCalculations = {};
     const metaCalculations = {};
+    const backtestCalculations = {}; // <-- ADD THIS
 
     for (const category in calculations) {
         // 1. Check for 'meta' category first (by top-level directory name)
@@ -37,8 +39,20 @@ function categorizeCalculations(calculations) {
             }
             continue; // Done with this category
         }
+        
+        // 2. Check for 'backtests' category
+        if (category === 'backtests') { // <-- ADD THIS BLOCK
+            if (!backtestCalculations[category]) backtestCalculations[category] = {};
+            for (const calcName in calculations[category]) {
+                const CalculationClass = calculations[category][calcName];
+                backtestCalculations[category][calcName] = CalculationClass;
+                BACKTEST_CALC_NAMES.add(calcName);
+            }
+            continue;
+        }
+
 
-        // 2. Process other categories (e.g., 'pnl', 'capital_flow')
+        // 3. Process other categories (e.g., 'pnl', 'capital_flow')
         for (const subKey in calculations[category]) {
             const item = calculations[category][subKey];
 
@@ -71,8 +85,10 @@ function categorizeCalculations(calculations) {
         historicalCalculations,
         dailyCalculations,
         metaCalculations,
+        backtestCalculations, // <-- ADD THIS
         HISTORICAL_CALC_NAMES,
-        META_CALC_NAMES
+        META_CALC_NAMES,
+        BACKTEST_CALC_NAMES  // <-- ADD THIS
     };
 }
 // --- End Dynamic Categorization ---

package/functions/generic-api/helpers/api_helpers.js

@@ -1,9 +1,63 @@
 /**
  * @fileoverview API sub-pipes.
  * REFACTORED: Now stateless and receive dependencies.
+ * NEW: Added getDynamicSchema to "test run" calculations
+ * by mocking async dependencies.
  */
 
 const { FieldPath } = require('@google-cloud/firestore');
+// --- NEW: Import calculation utils for mocking ---
+// We import 'aiden-shared-calculations-unified' to access its 'utils'
+const { utils } = require('aiden-shared-calculations-unified');
+
+// --- NEW: Store original utils ---
+const originalLoadMappings = utils.loadInstrumentMappings;
+const originalLoadPrices = utils.loadAllPriceData;
+const originalGetSectorMap = utils.getInstrumentSectorMap;
+
+// --- NEW: Define Mocks ---
+// This mock data will be "injected" into the calculations during the test run
+const mockMappings = { instrumentToTicker: { 1: 'TEST_TICKER', 2: 'ANOTHER' }, instrumentToSector: { 1: 'Test Sector', 2: 'Other' } };
+const mockPrices = { 1: { '2025-01-01': 100, '2025-01-02': 102 } };
+
+const mockPos = { InstrumentID: 1, NetProfit: 0.05, InvestedAmount: 50, Amount: 1000, Value: 55, Direction: 'Buy', IsBuy: true, PositionID: 123, OpenRate: 100, StopLossRate: 90, TakeProfitRate: 120, Leverage: 1, IsTslEnabled: false, OpenDateTime: '2025-01-01T12:00:00Z', CurrentRate: 105 };
+const mockToday = { AggregatedPositions: [mockPos, { ...mockPos, InstrumentID: 2 }], PublicPositions: [mockPos, { ...mockPos, InstrumentID: 2 }], PortfolioValue: 110 };
+const mockYesterday = { AggregatedPositions: [mockPos], PublicPositions: [mockPos], PortfolioValue: 100 };
+const mockInsights = { insights: [{ instrumentId: 1, total: 100, buy: 50, sell: 50 }] };
+const mockSocial = { 'post1': { tickers: ['TEST_TICKER'], sentiment: { overallSentiment: 'Bullish', topics: ['AI'] }, likeCount: 5, commentCount: 2, fullText: 'TEST_TICKER AI' } };
+
+// A mock context that's passed to process()
+const mockContext = { 
+    instrumentMappings: mockMappings.instrumentToTicker, 
+    sectorMapping: mockMappings.instrumentToSector,
+    todayDateStr: '2025-01-02',
+    yesterdayDateStr: '2025-01-01',
+    dependencies: { // For meta-calcs that read other calc results
+        db: { // Mock the DB to return fake data
+            collection: function() { return this; },
+            doc: function() { return this; },
+            get: async () => ({ 
+                exists: true, 
+                data: () => ({ /* mock data for meta-calc deps */ 
+                    'asset-crowd-flow': { 'TEST_TICKER': { net_crowd_flow_pct: 1.5 } },
+                    'social_sentiment_aggregation': { 'tickerSentiment': { 'TEST_TICKER': { sentimentRatio: 80 } } },
+                    'daily_investor_scores': { 'user123': 8.5 }
+                }) 
+            }),
+            getAll: async (...refs) => refs.map(ref => ({ 
+                exists: true, 
+                data: () => ({ /* mock data for meta-calc deps */ 
+                    'asset-crowd-flow': { 'TEST_TICKER': { net_crowd_flow_pct: 1.5 } },
+                    'social_sentiment_aggregation': { 'tickerSentiment': { 'TEST_TICKER': { sentimentRatio: 80 } } }
+                }) 
+            }))
+        },
+        logger: { log: () => {} } // Suppress logs during test run
+    },
+    config: {} // For meta-calcs
+};
+// --- END NEW MOCKS ---
+
 
 /**
  * Sub-pipe: pipe.api.helpers.validateRequest
@@ -31,10 +85,20 @@ const validateRequest = (query, config) => {
 const buildCalculationMap = (unifiedCalculations) => {
     const calcMap = {};
     for (const category in unifiedCalculations) {
-        for (const calcName in unifiedCalculations[category]) {
-            calcMap[calcName] = {
-                category: category,
-            };
+        for (const subKey in unifiedCalculations[category]) {
+            const item = unifiedCalculations[category][subKey];
+
+            // Handle historical subdirectory
+            if (subKey === 'historical' && typeof item === 'object') {
+                for (const calcName in item) {
+                    calcMap[calcName] = { category: category };
+                }
+            } 
+            // Handle regular daily/meta/social calc
+            else if (typeof item === 'function') {
+                const calcName = subKey;
+                calcMap[calcName] = { category: category };
+            }
         }
     }
     return calcMap;
@@ -157,16 +221,31 @@ const createApiHandler = (config, dependencies, calcMap) => {
  */
 function createStructureSnippet(data, maxKeys = 20) {
     if (data === null || typeof data !== 'object') {
+        // Handle primitive types
+        if (typeof data === 'number') return 0;
+        if (typeof data === 'string') return "string";
+        if (typeof data === 'boolean') return true;
         return data;
     }
     if (Array.isArray(data)) {
         if (data.length === 0) {
             return "<empty array>";
         }
+        // Generalize array contents to just the first element's structure
         return [ createStructureSnippet(data[0], maxKeys) ];
     }
     const newObj = {};
     const keys = Object.keys(data);
+    
+    // Check if it's an "example" object (like { "AAPL": {...} })
+    // This heuristic identifies keys that are all-caps or look like example tickers
+    if (keys.length > 0 && keys.every(k => k.match(/^[A-Z.]+$/) || k.includes('_') || k.match(/^[0-9]+$/))) {
+        const exampleKey = keys[0];
+        newObj[exampleKey] = createStructureSnippet(data[exampleKey], maxKeys);
+        newObj["... (more items)"] = "...";
+        return newObj;
+    }
+
     if (keys.length > maxKeys) {
         const firstKey = keys[0] || "example_key";
         newObj[firstKey] = createStructureSnippet(data[firstKey], maxKeys);
@@ -181,11 +260,7 @@ function createStructureSnippet(data, maxKeys = 20) {
 
 /**
  * Sub-pipe: pipe.api.helpers.getComputationStructure
- * @param {string} computationName
- * @param {object} calcMap
- * @param {object} config
- * @param {object} dependencies - Contains db, logger.
- * @returns {Promise<object>} A result object with status and data or error.
+ * (This is now a debug tool to check *live* data)
  */
 async function getComputationStructure(computationName, calcMap, config, dependencies) {
     const { db, logger } = dependencies;
@@ -244,10 +319,62 @@ async function getComputationStructure(computationName, calcMap, config, depende
 }
 
 
+/**
+ * --- NEW: DYNAMIC SCHEMA GENERATION HARNESS ---
+ * @param {class} CalcClass The calculation class to test.
+ * @param {string} calcName The name of the calculation for logging.
+ * @returns {Promise<object>} A snippet of the output structure.
+ */
+async function getDynamicSchema(CalcClass, calcName) {
+    // 1. Apply Mocks (Monkey-Patching)
+    utils.loadInstrumentMappings = async () => mockMappings;
+    utils.loadAllPriceData = async () => mockPrices;
+    utils.getInstrumentSectorMap = async () => mockMappings.instrumentToSector;
+
+    let result = {};
+    const calc = new CalcClass();
+
+    try {
+        // 2. Check for Meta-Calculation signature: process(dateStr, dependencies, config)
+        const processStr = calc.process.toString();
+        if (processStr.includes('dateStr') && processStr.includes('dependencies')) {
+            // It's a meta-calc. Run its process() with mock dependencies
+            result = await calc.process('2025-01-02', mockContext.dependencies, mockContext.config);
+        } else {
+            // It's a standard calculation. Run process() + getResult()
+            await calc.process(
+                mockToday, 
+                mockYesterday, 
+                'test-user-123', 
+                mockContext, 
+                mockInsights, // todayInsights
+                mockInsights, // yesterdayInsights
+                mockSocial,   // todaySocial
+                mockSocial    // yesterdaySocial
+            );
+            result = await calc.getResult();
+        }
+    } catch (e) {
+        console.error(`Error running schema test for ${calcName}: ${e.message}`);
+        result = { "ERROR": `Failed to generate schema: ${e.message}` };
+    } finally {
+        // 3. Restore Original Functions
+        utils.loadInstrumentMappings = originalLoadMappings;
+        utils.loadAllPriceData = originalLoadPrices;
+        utils.getInstrumentSectorMap = originalGetSectorMap;
+    }
+
+    // 4. Sanitize the result to just a "structure"
+    return createStructureSnippet(result);
+}
+// --- END NEW HARNESS ---
+
+
 module.exports = {
     validateRequest,
     buildCalculationMap,
     fetchUnifiedData,
     createApiHandler,
     getComputationStructure,
-};
+    getDynamicSchema // <-- EXPORT NEW HELPER
+};

package/functions/generic-api/index.js

@@ -1,7 +1,8 @@
 /**
  * @fileoverview Main entry point for the Generic API module.
  * Exports the 'createApiApp' main pipe function.
- * REFACTORED: 'createApiApp' now passes dependencies to sub-pipes.
+ * REFACTORED: /manifest endpoint now uses a dynamic "test harness"
+ * to generate the schema without modifying calculation files.
  */
 
 const express = require('express');
@@ -10,7 +11,8 @@ const { FieldPath } = require('@google-cloud/firestore');
 const { 
     buildCalculationMap, 
     createApiHandler, 
-    getComputationStructure 
+    getComputationStructure,
+    getDynamicSchema // <-- IMPORT NEW HELPER
 } = require('./helpers/api_helpers.js');
 
 /**
@@ -18,12 +20,12 @@ const {
  * Creates and configures the Express app for the Generic API.
  * @param {object} config - The Generic API V2 configuration object.
  * @param {object} dependencies - Shared dependencies { db, logger }.
- * @param {Object} unifiedCalculations - The calculations manifest.
+ * @param {Object} unifiedCalculations - The calculations manifest from 'aiden-shared-calculations-unified'.
  * @returns {express.Application} The configured Express app.
  */
 function createApiApp(config, dependencies, unifiedCalculations) {
     const app = express();
-    const { logger } = dependencies; // db is inside dependencies
+    const { logger } = dependencies; // db is in dependencies
 
     // --- Pre-compute Calculation Map ---
     const calcMap = buildCalculationMap(unifiedCalculations);
@@ -33,7 +35,6 @@ function createApiApp(config, dependencies, unifiedCalculations) {
     app.use(express.json());
 
     // --- Main API Endpoint ---
-    // createApiHandler is a factory that returns the actual handler
     app.get('/', createApiHandler(config, dependencies, calcMap));
 
     // --- Health Check Endpoint ---
@@ -56,7 +57,7 @@ function createApiApp(config, dependencies, unifiedCalculations) {
         }
     });
 
-    // --- REVISED: Debug Endpoint to get the structure from Firestore ---
+    // --- Debug Endpoint to get *stored* structure from Firestore ---
     app.get('/structure/:computationName', async (req, res) => {
         const { computationName } = req.params;
         
@@ -71,56 +72,67 @@ function createApiApp(config, dependencies, unifiedCalculations) {
         res.status(200).send(result);
     });
 
-    // --- NEW: Debug Endpoint to generate the full structure manifest ---
+    // --- NEW: Fully Refactored Manifest Endpoint (Dynamic Test Run) ---
     app.get('/manifest', async (req, res) => {
+        logger.log('INFO', 'API /manifest dynamic generation starting...');
         try {
-            const allKeys = Object.keys(calcMap).sort();
-            
-            const promises = allKeys.map(key => 
-                // Call sub-pipe, passing dependencies
-                getComputationStructure(key, calcMap, config, dependencies)
-            );
-            
-            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') {
-                    const errorData = result.value;
-                    errors.push({
-                        computation: errorData.computation,
-                        message: errorData.message,
-                    });
-                } else {
-                    errors.push({
-                        computation: "Unknown (Promise rejected)",
-                        message: result.reason.message,
-                    });
+            const errors = [];
+            
+            // This logic iterates through the calculation module structure
+            for (const category in unifiedCalculations) {
+                for (const subKey in unifiedCalculations[category]) {
+                    const item = unifiedCalculations[category][subKey];
+                    let calcName = null;
+                    let CalcClass = null;
+
+                    // Handle nested 'historical' directory
+                    if (subKey === 'historical' && typeof item === 'object') {
+                        for (const name in item) {
+                            calcName = name;
+                            CalcClass = item[name];
+                            if (CalcClass && typeof CalcClass === 'function') {
+                                try {
+                                    manifest[calcName] = {
+                                        category: category,
+                                        structure: await getDynamicSchema(CalcClass, calcName) // <-- DYNAMIC CALL
+                                    };
+                                    successCount++;
+                                } catch (e) { errors.push(`${category}/${calcName}: ${e.message}`); }
+                            }
+                        }
+                    } 
+                    // Handle regular calc at root of category
+                    else if (typeof item === 'function') {
+                        calcName = subKey;
+                        CalcClass = item;
+                        if (CalcClass && typeof CalcClass === 'function') {
+                             try {
+                                manifest[calcName] = {
+                                    category: category,
+                                    structure: await getDynamicSchema(CalcClass, calcName) // <-- DYNAMIC CALL
+                                };
+                                successCount++;
+                            } catch (e) { errors.push(`${category}/${calcName}: ${e.message}`); }
+                        }
+                    }
                 }
-            });
+            }
 
-            logger.log('INFO', `API /manifest complete. ${successCount}/${allKeys.length} computations successful.`);
+            const totalComputations = Object.keys(calcMap).length;
+            logger.log('INFO', `API /manifest complete. Generated schema for ${successCount}/${totalComputations} computations.`);
 
             res.status(200).send({
                 status: 'success',
                 summary: {
-                    totalComputations: allKeys.length,
-                    successful: successCount,
-                    failed: errors.length,
+                    source: 'computation_module_dynamic_test',
+                    totalComputations: totalComputations,
+                    schemasGenerated: successCount,
+                    schemasFailed: errors.length,
                 },
-                manifest,
-                errors,
+                manifest: manifest,
+                errors: errors.length > 0 ? errors : undefined,
             });
 
         } catch (error) {
@@ -136,4 +148,4 @@ module.exports = {
     createApiApp,
     // Exporting helpers so they can be part of the pipe.api.helpers object
     helpers: require('./helpers/api_helpers'), 
-};
+};

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

@@ -4,11 +4,9 @@
  * candle API into the new sharded `asset_prices` collection.
  */
 
-const { FieldValue } = require('@google-cloud/firestore');
-// --- REMOVED ---
-// const { loadInstrumentMappings } = require('aiden-shared-calculations-unified').utils;
-// --- END REMOVED ---
-const pLimit = require('p-limit');
+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 CONCURRENT_REQUESTS = 10;
@@ -54,7 +52,7 @@ exports.runBackfillAssetPrices = async (config, dependencies) => {
         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}`;
+                const url = `https://candle.etoro.com/candles/asc.json/OneDay/${DAYS_TO_FETCH}/${instrumentId}`; //TODO implement config value
                 
                 const selectedHeader = await headerManager.selectHeader();
                 let wasSuccess = false;

package/package.json

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