bulltrackers-module 1.0.196 → 1.0.198

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

@@ -7,8 +7,9 @@
  * It validates metadata, resolves dependencies, and performs a topological sort
  * to determine execution passes.
  *
- * It explicitly skips the 'legacy' package.
- * It has removed all logic for deprecated folder structures (e.g., /historical/).
+ * UPDATED LOGIC:
+ * - Core Computations: Metadata 'category' determines the output path/grouping.
+ * - Product Lines: Folder name STRICTLY determines the category (metadata ignored).
  */
 
 /* --------------------------------------------------
@@ -31,7 +32,7 @@ const log = {
 const normalizeName = (name) => { if (typeof name !== 'string') return name; return name.trim().replace(/,$/, '').replace(/_/g, '-').toLowerCase(); };
 
 /**
- * Finds the closest string matches for a typo. // https://medium.com/@ethannam/understanding-the-levenshtein-distance-equation-for-beginners-c4285a5604f0
+ * Finds the closest string matches for a typo.
  */
 function suggestClosest(name, candidates, n = 3) {
     const levenshtein = (a = '', b = '') => {
@@ -97,30 +98,53 @@ function buildManifest(productLinesToRun = [], calculations) {
     /* ---------------- 1. Load All Calculations ---------------- */
     log.step('Loading and validating all calculation classes…');
     const allCalculationClasses = new Map();
+
     /**
      * Processes a single calculation class, validates it, and adds to maps.
-     * --- REFACTOR: Simplified signature, isHistorical is now read from metadata ---
+     * @param {Class} Class - The calculation class structure.
+     * @param {string} name - The filename/key.
+     * @param {string} folderName - The folder this file came from (e.g. 'core', 'gem').
      */
-    function processCalc(Class, name, category) {
+    function processCalc(Class, name, folderName) {
         if (!Class || typeof Class !== 'function') return;
         const normalizedName = normalizeName(name);
         allCalculationClasses.set(normalizedName, Class);
+        
         // --- RULE 1: Check for static getMetadata() ---
         if (typeof Class.getMetadata !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing the static getMetadata() method. Build FAILED.`); hasFatalError = true; return; }
         // --- RULE 2: Check for static getDependencies() ---
         if (typeof Class.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing the static getDependencies() method. Build FAILED.`); hasFatalError = true;return; }
         // --- RULE 3: Check for static getSchema() ---
         if (typeof Class.getSchema !== 'function') {log.warn(`Calculation "${normalizedName}" is missing the static getSchema() method. (Recommended)`); }
+        
         const metadata     = Class.getMetadata();
         const dependencies = Class.getDependencies().map(normalizeName);
+        
         // --- RULE 4: Check for isHistorical mismatch ---
-        if (metadata.isHistorical === true && !Class.toString().includes('yesterday')) { // UPDATED FOR MATH LAYER, TODO THIS IS A LITTLE BRITTLE, BUT FOR NOW FINE...
+        if (metadata.isHistorical === true && !Class.toString().includes('yesterday')) { 
             log.warn(`Calculation "${normalizedName}" is marked 'isHistorical: true' but does not seem to reference 'yesterday' data.`); 
         }
+
+        // --- RULE 5: Category Enforcement Logic ---
+        let finalCategory = folderName; // Default to folder name
+
+        if (folderName === 'core') {
+            // For CORE: We respect metadata.category if it exists. 
+            // This allows core computations to write to specific output paths (e.g. 'market_stats').
+            if (metadata.category) {
+                finalCategory = metadata.category;
+            }
+        } else {
+            // For PRODUCT LINES: We IGNORE metadata.category and enforce the folder name.
+            // This ensures product lines always group correctly regardless of typos in metadata.
+            finalCategory = folderName;
+        }
+
         const manifestEntry = {
             name: normalizedName,
             class: Class,
-            category: metadata.category || category, 
+            category: finalCategory,     // The logic category / output path
+            sourcePackage: folderName,   // The physical source folder (used for "Core Always Run" checks)
             type: metadata.type,
             isHistorical: metadata.isHistorical, 
             rootDataDependencies: metadata.rootDataDependencies || [],
@@ -131,19 +155,23 @@ function buildManifest(productLinesToRun = [], calculations) {
         manifestMap.set(normalizedName, manifestEntry);
         adjacency.set(normalizedName, dependencies);
         inDegree.set(normalizedName, dependencies.length);
-        dependencies.forEach(dep => { if (!reverseAdjacency.has(dep)) reverseAdjacency.set(dep, []); reverseAdjacency.get(dep).push(normalizedName); }); }
+        dependencies.forEach(dep => { if (!reverseAdjacency.has(dep)) reverseAdjacency.set(dep, []); reverseAdjacency.get(dep).push(normalizedName); }); 
+    }
     
     if (!calculations || typeof calculations !== 'object') {
         log.fatal('Calculations object was not provided or is invalid.');
         throw new Error('Manifest build failed: Invalid calculations object.');
     }
 
-    for (const category in calculations) {
-        if (category === 'legacy') { log.info('Skipping "legacy" calculations package.'); continue; }
-        const group = calculations[category];
+    // Iterate over folders (folderName becomes the default category)
+    for (const folderName in calculations) {
+        if (folderName === 'legacy') { log.info('Skipping "legacy" calculations package.'); continue; }
+        const group = calculations[folderName];
         for (const key in group) {
             const entry = group[key];
-            if (typeof entry === 'function') { processCalc(entry, key, category);  } } }
+            if (typeof entry === 'function') { processCalc(entry, key, folderName);  } 
+        } 
+    }
 
     if (hasFatalError) { throw new Error('Manifest build failed due to missing static methods in calculations.'); }
     log.success(`Loaded and validated ${manifestMap.size} total calculations.`);
@@ -171,13 +199,24 @@ function buildManifest(productLinesToRun = [], calculations) {
 
     /* ---------------- 3. Filter for Product Lines ---------------- */
     log.divider('Filtering by Product Line');
-    // 1. Find all "endpoint" calculations (the final signals) in the target product lines.
-
+    
+    // 1. Find all "endpoint" calculations in the target product lines.
+    // This checks the assigned category (which now matches the folder for all non-core lines).
     const productLineEndpoints = [];
-    for (const [name, entry] of manifestMap.entries()) { if (productLinesToRun.includes(entry.category)) { productLineEndpoints.push(name); } }
+    for (const [name, entry] of manifestMap.entries()) { 
+        if (productLinesToRun.includes(entry.category)) { 
+            productLineEndpoints.push(name); 
+        } 
+    }
 
     // 2. Add 'core' calculations as they are always included.
-    for (const [name, entry] of manifestMap.entries()) { if (entry.category === 'core') { productLineEndpoints.push(name); } }
+    // We check 'sourcePackage' here so that even if a core calculation has a custom category
+    // (like 'market_stats'), it is still recognized as Core and included.
+    for (const [name, entry] of manifestMap.entries()) { 
+        if (entry.sourcePackage === 'core') { 
+            productLineEndpoints.push(name); 
+        } 
+    }
 
     // 3. Trace all dependencies upwards from these endpoints.
     const requiredCalcs = getDependencySet(productLineEndpoints, adjacency);
@@ -227,9 +266,6 @@ function buildManifest(productLinesToRun = [], calculations) {
     return sortedManifest;
 }
 
-
-
-
 /**
  * Main entry point for building and exporting the manifest.
  * @param {string[]} productLinesToRun - Array of product line categories (folder names) to build for.
@@ -245,5 +281,4 @@ function build(productLinesToRun, calculations) {
     }
 }
 
-
-module.exports = { build}; 
+module.exports = { build };

package/package.json

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