bulltrackers-module 1.0.232 → 1.0.234

package/functions/computation-system/layers/extractors.js

@@ -104,6 +104,36 @@ class DataExtractor {
     }
     static getHasTSL(position) { return position ? (position.HasTrailingStopLoss === true) : false; }
     static getOpenDateTime(position) { return (!position || !position.OpenDateTime) ? null : new Date(position.OpenDateTime); }
+
+
+    /**
+     * Returns trades that were active during the given date's 24-hour window.
+     * @param {Array} historyTrades - The PublicHistoryPositions array.
+     * @param {string} dateStr - YYYY-MM-DD string.
+     */
+    static getActiveTradesForDate(historyTrades, dateStr) {
+        if (!historyTrades || !Array.isArray(historyTrades)) return [];
+        
+        // Define the day's window
+        const startTime = new Date(dateStr + "T00:00:00.000Z").getTime();
+        const endTime = new Date(dateStr + "T23:59:59.999Z").getTime();
+
+        return historyTrades.filter(t => {
+            if (!t.OpenDateTime) return false;
+            const openTime = new Date(t.OpenDateTime).getTime();
+            
+            // 1. Must be opened before the day ended
+            if (openTime > endTime) return false;
+
+            // 2. If closed, must be closed after the day started
+            if (t.CloseDateTime) {
+                const closeTime = new Date(t.CloseDateTime).getTime();
+                if (closeTime < startTime) return false;
+            }
+
+            return true;
+        });
+    }
 }
 
 class priceExtractor {

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

@@ -1,18 +1,18 @@
 /**
  * @fileoverview API sub-pipes.
- * REFACTORED: Implements Status-Based Availability Caching and Smart Date Resolution.
+ * REFACTORED: Fixed Category Resolution to match ManifestBuilder logic.
+ * Implements Status-Based Availability Caching and Smart Date Resolution.
  */
 
 const { FieldPath } = require('@google-cloud/firestore');
 
 // --- AVAILABILITY CACHE ---
-// Maintains a map of which computations are available on which dates.
 class AvailabilityCache {
     constructor(db, logger, ttlMs = 5 * 60 * 1000) { // 5 Minute TTL
         this.db = db;
         this.logger = logger;
         this.ttlMs = ttlMs;
-        this.cache = null; // { "calcName": ["2023-10-01", "2023-09-30"] } (Sorted DESC)
+        this.cache = null; 
         this.lastFetched = 0;
         this.statusCollection = 'computation_status';
     }
@@ -25,8 +25,7 @@ class AvailabilityCache {
 
         this.logger.log('INFO', '[AvailabilityCache] Refreshing availability map from Firestore...');
         
-        // Fetch last 400 days of status to build the map
-        // We only fetch keys and small status objects, so this is relatively cheap.
+        // Fetch recent status to build the map (Limit 400 days)
         const snapshot = await this.db.collection(this.statusCollection)
             .orderBy(FieldPath.documentId(), 'desc')
             .limit(400)
@@ -38,11 +37,9 @@ class AvailabilityCache {
             const dateStr = doc.id;
             const statusData = doc.data();
             
-            // Regex to validate date format YYYY-MM-DD
             if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return;
 
             for (const [calcName, status] of Object.entries(statusData)) {
-                // We consider it available if status is truthy and NOT 'IMPOSSIBLE'
                 if (status && status !== 'IMPOSSIBLE') {
                     if (!newMap[calcName]) newMap[calcName] = [];
                     newMap[calcName].push(dateStr);
@@ -62,30 +59,22 @@ class AvailabilityCache {
  */
 async function resolveTargetDates(availabilityCache, computationKeys, mode, limit) {
     const map = await availabilityCache.getMap();
-    const datesToFetch = new Set();
-
-    // 1. Identify all available dates for the requested computations
-    // We union the dates: if ANY requested calc is available on a date, we consider that date "relevant".
-    // (Alternatively, we could intersect, but union allows sparse data return).
-    const relevantDatesSet = new Set();
     
+    const relevantDatesSet = new Set();
     computationKeys.forEach(key => {
         const dates = map[key] || [];
         dates.forEach(d => relevantDatesSet.add(d));
     });
 
-    // Sort descending
     const sortedDates = Array.from(relevantDatesSet).sort((a, b) => b.localeCompare(a));
 
     if (sortedDates.length === 0) return [];
 
     if (mode === 'latest') {
-        // Return only the most recent date found
         return [sortedDates[0]];
     } 
     
     if (mode === 'series') {
-        // Return the last N available dates
         return sortedDates.slice(0, limit);
     }
 
@@ -98,7 +87,6 @@ async function resolveTargetDates(availabilityCache, computationKeys, mode, limi
 const validateRequest = (query) => {
     if (!query.computations) return "Missing 'computations' parameter.";
     
-    // New optional params, but computations is mandatory
     const allowedModes = ['latest', 'series'];
     if (query.mode && !allowedModes.includes(query.mode)) {
         return "Invalid 'mode'. Must be 'latest' or 'series'.";
@@ -116,19 +104,41 @@ const validateRequest = (query) => {
 
 /**
  * Sub-pipe: pipe.api.helpers.buildCalculationMap
+ * FIX APPLIED: Checks class metadata for category override (mirroring ManifestBuilder).
  */
 const buildCalculationMap = (unifiedCalculations) => {
     const calcMap = {};
+
+    // Helper to resolve category exactly like ManifestBuilder.js does
+    const resolveCategory = (cls, folderName) => {
+        if (typeof cls.getMetadata === 'function') {
+            const meta = cls.getMetadata();
+            // If folder is 'core', allow metadata to override
+            if (folderName === 'core' && meta.category) {
+                return meta.category;
+            }
+        }
+        return folderName;
+    };
+
     for (const category in unifiedCalculations) {
         for (const subKey in unifiedCalculations[category]) {
             const item = unifiedCalculations[category][subKey];
+            
             if (subKey === 'historical' && typeof item === 'object') {
                 for (const calcName in item) {
-                    calcMap[calcName] = { category: category, class: item[calcName] };
+                    const cls = item[calcName];
+                    calcMap[calcName] = { 
+                        category: resolveCategory(cls, category), 
+                        class: cls 
+                    };
                 }
             } else if (typeof item === 'function') {
                 const calcName = subKey;
-                calcMap[calcName] = { category: category, class: item };
+                calcMap[calcName] = { 
+                    category: resolveCategory(item, category), 
+                    class: item 
+                };
             }
         }
     }
@@ -137,7 +147,6 @@ const buildCalculationMap = (unifiedCalculations) => {
 
 /**
  * Sub-pipe: pipe.api.helpers.fetchUnifiedData
- * UPDATED: Uses specific date list derived from availability.
  */
 const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, calcMap) => {
     const { db, logger } = dependencies;
@@ -151,9 +160,8 @@ const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, cal
     try {
         const readPromises = [];
 
-        // Prepare all reads
         for (const date of dateStrings) {
-            response[date] = {}; // Init structure
+            response[date] = {}; 
             
             for (const key of calcKeys) {
                 const pathInfo = calcMap[key];
@@ -163,13 +171,16 @@ const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, cal
                         .collection(compsSub).doc(key);
                     
                     readPromises.push({ date, key, ref: docRef });
+                } else {
+                    // If no path info, we can't fetch.
+                    response[date][key] = null;
                 }
             }
         }
         
         if (readPromises.length === 0) return response;
 
-        // Batch reads in chunks (Firestore getAll limit is usually high, but let's be safe)
+        // Batch reads
         const CHUNK_SIZE = 100;
         for (let i = 0; i < readPromises.length; i += CHUNK_SIZE) {
             const chunk = readPromises.slice(i, i + CHUNK_SIZE);
@@ -182,8 +193,6 @@ const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, cal
                 if (doc.exists) {
                     response[date][key] = doc.data();
                 } else {
-                    // Start sparse: don't populate nulls to keep payload small?
-                    // Or populate null to indicate "checked but missing"
                     response[date][key] = null;
                 }
             });
@@ -198,12 +207,11 @@ const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, cal
 
 /**
  * Factory for the main API handler.
- * UPDATED: Uses AvailabilityCache to determine dates.
  */
 const createApiHandler = (config, dependencies, calcMap) => {
     const { logger, db } = dependencies;
     
-    // Instantiate Cache (Singleton scope within the closure)
+    // Singleton Cache
     const availabilityCache = new AvailabilityCache(db, logger);
 
     return async (req, res) => {
@@ -215,10 +223,10 @@ const createApiHandler = (config, dependencies, calcMap) => {
         
         try {
             const computationKeys = req.query.computations.split(',');
-            const mode = req.query.mode || 'latest'; // Default to latest
-            const limit = parseInt(req.query.limit) || 30; // Default 30 days for series
+            const mode = req.query.mode || 'latest'; 
+            const limit = parseInt(req.query.limit) || 30;
 
-            // 1. Resolve Dates based on Availability
+            // 1. Resolve Dates
             const dateStrings = await resolveTargetDates(availabilityCache, computationKeys, mode, limit);
 
             if (dateStrings.length === 0) {
@@ -234,12 +242,9 @@ const createApiHandler = (config, dependencies, calcMap) => {
                 });
             }
 
-            // 2. Fetch Data for these dates
+            // 2. Fetch Data
             const data = await fetchUnifiedData(config, dependencies, computationKeys, dateStrings, calcMap);
             
-            // 3. Cleanup sparse dates (optional: remove dates where all requested keys are null)
-            // For now, we return what was fetched.
-
             res.set('Cache-Control', 'public, max-age=300, s-maxage=3600');
             res.status(200).send({
                 status: 'success',
@@ -248,8 +253,8 @@ const createApiHandler = (config, dependencies, calcMap) => {
                     mode,
                     limit: mode === 'series' ? limit : 1,
                     dateRange: {
-                        start: dateStrings[dateStrings.length - 1], // Oldest
-                        end: dateStrings[0] // Newest
+                        start: dateStrings[dateStrings.length - 1], 
+                        end: dateStrings[0]
                     }
                 },
                 data,
@@ -261,10 +266,6 @@ const createApiHandler = (config, dependencies, calcMap) => {
     };
 };
 
-// ... (Previous Helper Functions: getComputationStructure, getDynamicSchema, createManifestHandler stay the same) ...
-/**
- * Internal helper for snippet generation.
- */
 function createStructureSnippet(data, maxKeys = 20) {
     if (data === null || typeof data !== 'object') {
         if (typeof data === 'number') return 0;
@@ -298,9 +299,6 @@ function createStructureSnippet(data, maxKeys = 20) {
     return newObj;
 }
 
-/**
- * Sub-pipe: pipe.api.helpers.getComputationStructure
- */
 async function getComputationStructure(computationName, calcMap, config, dependencies) {
     const { db, logger } = dependencies;
     try {
@@ -332,10 +330,6 @@ async function getComputationStructure(computationName, calcMap, config, depende
     }
 }
 
-
-/**
- * --- UPDATED: DYNAMIC SCHEMA GENERATION HARNESS ---
- */
 async function getDynamicSchema(CalcClass, calcName) {
     if (CalcClass && typeof CalcClass.getSchema === 'function') {
         try {
@@ -349,47 +343,31 @@ async function getDynamicSchema(CalcClass, calcName) {
     }
 }
 
-
-/**
- * --- NEW: MANIFEST API HANDLER (With Filtering) ---
- */
 const createManifestHandler = (config, dependencies, calcMap) => {
     const { db, logger } = dependencies;
     const schemaCollection = config.schemaCollection || 'computation_schemas';
     
     return async (req, res) => {
         try {
-            logger.log('INFO', '[API /manifest] Fetching all computation schemas...');
             const snapshot = await db.collection(schemaCollection).get();
-            
-            if (snapshot.empty) {
-                logger.log('WARN', '[API /manifest] No schemas found in collection.');
-                return res.status(404).send({ status: 'error', message: 'No computation schemas have been generated yet.' });
-            }
+            if (snapshot.empty) { return res.status(404).send({ status: 'error', message: 'No computation schemas have been generated yet.' }); }
 
-            // --- FILTERING LOGIC ---
             const manifest = {};
             const now = Date.now();
-            const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+            const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; 
             
             let activeCount = 0;
             let staleCount = 0;
 
             snapshot.forEach(doc => {
                 const data = doc.data();
-                
-                // Safe Timestamp conversion
                 let lastUpdatedMs = 0;
                 if (data.lastUpdated && typeof data.lastUpdated.toMillis === 'function') {
                     lastUpdatedMs = data.lastUpdated.toMillis();
                 } else if (data.lastUpdated instanceof Date) {
                     lastUpdatedMs = data.lastUpdated.getTime();
-                } else {
-                    // Fallback for very old records without a timestamp
-                    lastUpdatedMs = 0; 
                 }
 
-                // Exclude stale records
                 if ((now - lastUpdatedMs) < MAX_AGE_MS) {
                     manifest[doc.id] = {
                         category: data.category,
@@ -398,16 +376,9 @@ const createManifestHandler = (config, dependencies, calcMap) => {
                         lastUpdated: data.lastUpdated
                     };
                     activeCount++;
-                } else {
-                    staleCount++;
-                }
+                } else { staleCount++; }
             });
             
-            // Log filtering results
-            if (staleCount > 0) {
-                logger.log('INFO', `[API /manifest] Filtered out ${staleCount} stale schemas (older than 7 days). Returning ${activeCount} active.`);
-            }
-
             res.status(200).send({
                 status: 'success',
                 summary: {
@@ -415,15 +386,13 @@ const createManifestHandler = (config, dependencies, calcMap) => {
                     totalComputations: snapshot.size,
                     schemasAvailable: activeCount,
                     schemasFiltered: staleCount,
-                    lastUpdated: Math.max(...Object.values(manifest).map(m => 
-                         (m.lastUpdated && m.lastUpdated.toMillis) ? m.lastUpdated.toMillis() : 0 
-                    ), 0)
+                    lastUpdated: Date.now()
                 },
                 manifest: manifest
             });
 
         } catch (error) {
-            logger.log('ERROR', 'API /manifest handler failed.', { errorMessage: error.message, stack: error.stack });
+            logger.log('ERROR', 'API /manifest handler failed.', { errorMessage: error.message });
             res.status(500).send({ status: 'error', message: 'An internal error occurred.' });
         }
     };

package/package.json

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