bulltrackers-module 1.0.635 → 1.0.637

package/functions/computation-system/data/DependencyFetcher.js

@@ -44,7 +44,9 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {})
     const dStr = date.toISOString().slice(0, 10);
     
     // 1. Identify unique dependencies needed
-    const needed = new Set();
+    // CHANGED: Use a Map to track { normalizedName: originalName }
+    const needed = new Map();
+
     calcs.forEach(c => {
         // [FIX] Support both .getDependencies() method and .dependencies array
         const reqs = (typeof c.getDependencies === 'function') 
@@ -52,7 +54,12 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {})
             : (c.dependencies || []);
             
         if (Array.isArray(reqs)) {
-            reqs.forEach(r => needed.add(normalizeName(r)));
+            reqs.forEach(r => {
+                // We map the normalized version to the original requested version
+                // This ensures we fetch the right file (normalized) but return it 
+                // with the casing the user code expects (original).
+                needed.set(normalizeName(r), r);
+            });
         }
     });
     
@@ -61,14 +68,20 @@ async function fetchDependencies(date, calcs, config, deps, manifestLookup = {})
     logger.log('INFO', `[DependencyFetcher] Fetching ${needed.size} dependencies for ${dStr}`);
     
     const results = {};
-    const promises = Array.from(needed).map(async (name) => {
+    // CHANGED: Iterate over the entries to access both normalized and original names
+    const promises = Array.from(needed.entries()).map(async ([normName, originalName]) => {
         try {
             // Resolve Category from Lookup, default to 'analytics' if unknown
-            const category = manifestLookup[name] || 'analytics'; 
-            const data = await fetchSingleResult(db, config, dStr, name, category);
-            if (data) results[name] = data;
+            // Note: manifestLookup keys are expected to be normalized
+            const category = manifestLookup[normName] || 'analytics'; 
+            
+            // Fetch using the normalized name (system standard)
+            const data = await fetchSingleResult(db, config, dStr, normName, category);
+            
+            // CHANGED: Store result using the ORIGINAL name so context.computed['CaseSensitive'] works
+            if (data) results[originalName] = data;
         } catch (e) {
-            logger.log('WARN', `[DependencyFetcher] Failed to load dependency ${name}: ${e.message}`);
+            logger.log('WARN', `[DependencyFetcher] Failed to load dependency ${originalName}: ${e.message}`);
         }
     });
     

package/functions/computation-system/tools/DeploymentValidator.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Comprehensive Computation Validator
  * Validates computation structure, metadata, and code compliance during build
+ * UPDATED: Added Static Dependency Verification to prove context.computed access.
  */
 
 const acorn = require('acorn');
@@ -134,7 +135,8 @@ class ComputationValidator {
             this.validateDependencies(dependencies, name);
             
             // 4. Code Analysis (AST)
-            this.validateCode(CalcClass, name, metadata);
+            // UPDATED: Passing dependencies to enable context.computed verification
+            this.validateCode(CalcClass, name, metadata, dependencies);
             
             // 5. Schema Validation (if present)
             if (typeof CalcClass.getSchema === 'function') {
@@ -305,7 +307,7 @@ class ComputationValidator {
     /**
      * 4. Code Analysis (AST-based)
      */
-    validateCode(CalcClass, name, metadata) {
+    validateCode(CalcClass, name, metadata, dependencies) {
         const processSource = CalcClass.prototype.process.toString();
         
         // Parse AST
@@ -336,6 +338,8 @@ class ComputationValidator {
         this.analyzeContextUsage(ast, name, metadata);
         this.analyzeLayerUsage(ast, name);
         this.analyzeResultAssignment(ast, name, metadata);
+        // UPDATED: Analyze Dependency Validity
+        this.analyzeDependencyUsage(ast, name, dependencies);
     }
 
     analyzeContextUsage(ast, name, metadata) {
@@ -386,6 +390,52 @@ class ComputationValidator {
         });
     }
 
+    /**
+     * [NEW] Analyzes usage of context.computed to ensure variables exist
+     */
+    analyzeDependencyUsage(ast, name, dependencies) {
+        const declaredSet = new Set(dependencies);
+        const self = this;
+
+        walk.simple(ast, {
+            MemberExpression(node) {
+                // Look for: context.computed['Key'] OR context.computed.Key
+                if (node.object.type === 'MemberExpression' &&
+                    node.object.object.type === 'Identifier' &&
+                    node.object.object.name === 'context' &&
+                    node.object.property.name === 'computed') {
+                    
+                    let accessedKey = null;
+
+                    // Case 1: Dot notation (context.computed.SomeDep)
+                    if (!node.computed && node.property.type === 'Identifier') {
+                        accessedKey = node.property.name;
+                    }
+                    // Case 2: Bracket notation with string literal (context.computed['SomeDep'])
+                    else if (node.computed && node.property.type === 'Literal') {
+                        accessedKey = node.property.value;
+                    }
+
+                    if (accessedKey) {
+                        if (!declaredSet.has(accessedKey)) {
+                            // Check for casing mismatches to give helpful errors
+                            const caseInsensitiveMatch = dependencies.find(d => d.toLowerCase() === accessedKey.toLowerCase());
+                            
+                            if (caseInsensitiveMatch) {
+                                self.errors.push(`[${name}] Dependency Casing Mismatch: Accessed '${accessedKey}' but declared '${caseInsensitiveMatch}'. Keys are case-sensitive.`);
+                            } else {
+                                self.errors.push(`[${name}] Accessing undeclared dependency: '${accessedKey}'. Add it to getDependencies() or fix the typo.`);
+                            }
+                        }
+                    } else if (node.computed) {
+                        // Dynamic access (e.g. context.computed[someVar])
+                        self.warnings.push(`[${name}] Dynamic access to context.computed detected. Cannot statically verify dependency existence.`);
+                    }
+                }
+            }
+        });
+    }
+
     analyzeResultAssignment(ast, name, metadata) {
         let assignsToResults = false;
         let hasReturn = false;

package/package.json

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