bulltrackers-module 1.0.731 → 1.0.733

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

@@ -1,536 +0,0 @@
-/**
- * @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');
-const walk = require('acorn-walk');
-
-// Import allowed layer exports for validation
-const mathLayer = require('../layers/mathematics');
-const extractorsLayer = require('../layers/extractors');
-const profilingLayer = require('../layers/profiling');
-const validatorsLayer = require('../layers/validators');
-
-/**
- * VALIDATION RULESET CONFIGURATION
- */
-const VALIDATION_RULES = {
-    // Allowed metadata fields
-    ALLOWED_METADATA_FIELDS: new Set([
-        'name', 'type', 'category', 'isPage', 'isHistorical', 'isTest',
-        'rootDataDependencies', 'rootDataSeries', 'dependencySeries',
-        'mandatoryRoots', 'canHaveMissingRoots', 'canHaveMissingSeries',
-        'userType', 'schedule', 'ttlDays', 'isAlertComputation',
-        'requiresEarliestDataDate'
-    ]),
-
-    // Valid computation types
-    VALID_TYPES: new Set(['standard', 'meta']),
-
-    // Valid user types
-    VALID_USER_TYPES: new Set([
-        'all', 'normal', 'speculator', 'popular_investor', 'signed_in_user',
-        'NORMAL', 'SPECULATOR', 'POPULAR_INVESTOR', 'SIGNED_IN_USER'
-    ]),
-
-    // Valid root data dependencies
-    VALID_ROOT_DATA_DEPS: new Set([
-        'portfolio', 'history', 'social', 'insights', 'price',
-        'rankings', 'verification', 'ratings', 'pageViews',
-        'watchlist', 'alerts', 'piMasterList'
-    ]),
-
-    // Valid schedule types
-    VALID_SCHEDULE_TYPES: new Set(['DAILY', 'WEEKLY', 'MONTHLY']),
-
-    // Context structure for 'standard' type
-    STANDARD_CONTEXT_STRUCTURE: new Set([
-        'user', 'date', 'insights', 'social', 'mappings', 'math',
-        'computed', 'previousComputed', 'meta', 'config', 'deps',
-        'globalData', 'system'
-    ]),
-
-    // Context structure for 'meta' type
-    META_CONTEXT_STRUCTURE: new Set([
-        'date', 'insights', 'social', 'prices', 'mappings', 'math',
-        'computed', 'previousComputed', 'meta', 'config', 'deps',
-        'globalData'
-    ]),
-
-    // Allowed layer functions (built dynamically)
-    ALLOWED_LAYER_FUNCTIONS: new Map(),
-
-    // Forbidden patterns
-    FORBIDDEN_PATTERNS: [
-        { pattern: /localStorage/g, message: 'localStorage is not supported in Cloud Functions' },
-        { pattern: /sessionStorage/g, message: 'sessionStorage is not supported in Cloud Functions' },
-        { pattern: /window\./g, message: 'window object is not available in Node.js environment' },
-        { pattern: /document\./g, message: 'document object is not available in Node.js environment' },
-        { pattern: /require\(/g, message: 'Dynamic require() is forbidden. Use dependency injection.' },
-        { pattern: /eval\(/g, message: 'eval() is forbidden for security reasons' },
-        { pattern: /Function\(/g, message: 'Function constructor is forbidden for security reasons' }
-    ],
-
-    // Warning patterns (non-blocking)
-    WARNING_PATTERNS: [
-        { pattern: /console\.log/g, message: 'Use context.deps.logger instead of console.log' },
-        { pattern: /Math\.random/g, message: 'Math.random() is non-deterministic. Consider using SeededRandom for reproducibility.' },
-        { pattern: /new Date\(\)/g, message: 'new Date() without arguments may cause timezone issues. Use context.date.today.' }
-    ]
-};
-
-// Build allowed layer functions map
-function buildLayerFunctionsMap() {
-    const map = new Map();
-    
-    const layers = {
-        math: mathLayer,
-        extractors: extractorsLayer,
-        profiling: profilingLayer,
-        validators: validatorsLayer
-    };
-
-    for (const [layerName, layerExports] of Object.entries(layers)) {
-        for (const exportName of Object.keys(layerExports)) {
-            const fullPath = `${layerName}.${exportName}`;
-            map.set(fullPath, { layer: layerName, export: exportName });
-            
-            // Also allow direct access (e.g., MathPrimitives)
-            map.set(exportName, { layer: layerName, export: exportName });
-        }
-    }
-    
-    return map;
-}
-
-VALIDATION_RULES.ALLOWED_LAYER_FUNCTIONS = buildLayerFunctionsMap();
-
-/**
- * MAIN VALIDATOR CLASS
- */
-class ComputationValidator {
-    constructor() {
-        this.errors = [];
-        this.warnings = [];
-    }
-
-    /**
-     * Validates a single calculation class
-     */
-    validate(CalcClass) {
-        const name = CalcClass.name || 'Unknown';
-        
-        try {
-            // 1. Structural Validation
-            this.validateStructure(CalcClass, name);
-            
-            // 2. Metadata Validation
-            const metadata = CalcClass.getMetadata();
-            this.validateMetadata(metadata, name);
-            
-            // 3. Dependencies Validation
-            const dependencies = CalcClass.getDependencies();
-            this.validateDependencies(dependencies, name);
-            
-            // 4. Code Analysis (AST)
-            // UPDATED: Passing dependencies to enable context.computed verification
-            this.validateCode(CalcClass, name, metadata, dependencies);
-            
-            // 5. Schema Validation (if present)
-            if (typeof CalcClass.getSchema === 'function') {
-                this.validateSchema(CalcClass.getSchema(), name);
-            }
-
-        } catch (e) {
-            this.errors.push(`[${name}] Validation crashed: ${e.message}`);
-        }
-    }
-
-    /**
-     * 1. Structural Validation
-     */
-    validateStructure(CalcClass, name) {
-        const proto = CalcClass.prototype;
-        
-        // Required static methods
-        if (typeof CalcClass.getMetadata !== 'function') {
-            this.errors.push(`[${name}] Missing static getMetadata() method`);
-        }
-        
-        if (typeof CalcClass.getDependencies !== 'function') {
-            this.errors.push(`[${name}] Missing static getDependencies() method`);
-        }
-        
-        // Required instance methods
-        if (typeof proto.process !== 'function') {
-            this.errors.push(`[${name}] Missing process() instance method`);
-        }
-        
-        if (typeof proto.getResult !== 'function') {
-            this.errors.push(`[${name}] Missing getResult() instance method`);
-        }
-    }
-
-    /**
-     * 2. Metadata Validation
-     */
-    validateMetadata(metadata, name) {
-        if (!metadata || typeof metadata !== 'object') {
-            this.errors.push(`[${name}] getMetadata() must return an object`);
-            return;
-        }
-
-        // Check for unknown fields
-        for (const field of Object.keys(metadata)) {
-            if (!VALIDATION_RULES.ALLOWED_METADATA_FIELDS.has(field)) {
-                this.warnings.push(`[${name}] Unknown metadata field: "${field}"`);
-            }
-        }
-
-        // Validate type
-        if (!metadata.type) {
-            this.errors.push(`[${name}] Missing required metadata field: "type"`);
-        } else if (!VALIDATION_RULES.VALID_TYPES.has(metadata.type)) {
-            this.errors.push(`[${name}] Invalid type "${metadata.type}". Must be "standard" or "meta"`);
-        }
-
-        // Validate category
-        if (!metadata.category) {
-            this.warnings.push(`[${name}] Missing metadata field: "category"`);
-        }
-
-        // Validate userType (for standard computations)
-        if (metadata.type === 'standard') {
-            if (!metadata.userType) {
-                this.warnings.push(`[${name}] Standard computation missing userType. Defaulting to "all"`);
-            } else if (!VALIDATION_RULES.VALID_USER_TYPES.has(metadata.userType)) {
-                this.errors.push(`[${name}] Invalid userType "${metadata.userType}"`);
-            }
-        }
-
-        // Validate rootDataDependencies
-        if (metadata.rootDataDependencies) {
-            if (!Array.isArray(metadata.rootDataDependencies)) {
-                this.errors.push(`[${name}] rootDataDependencies must be an array`);
-            } else {
-                for (const dep of metadata.rootDataDependencies) {
-                    if (!VALIDATION_RULES.VALID_ROOT_DATA_DEPS.has(dep)) {
-                        this.errors.push(`[${name}] Invalid root data dependency: "${dep}"`);
-                    }
-                }
-            }
-        }
-
-        // Validate schedule
-        if (metadata.schedule) {
-            if (!metadata.schedule.type || !VALIDATION_RULES.VALID_SCHEDULE_TYPES.has(metadata.schedule.type)) {
-                this.errors.push(`[${name}] Invalid schedule type. Must be DAILY, WEEKLY, or MONTHLY`);
-            }
-            
-            if (metadata.schedule.type === 'WEEKLY' && !metadata.schedule.days) {
-                this.errors.push(`[${name}] Weekly schedule missing "days" array`);
-            }
-            
-            if (metadata.schedule.type === 'MONTHLY' && !metadata.schedule.days) {
-                this.errors.push(`[${name}] Monthly schedule missing "days" array`);
-            }
-        }
-
-        // Validate TTL
-        if (metadata.ttlDays !== undefined) {
-            if (typeof metadata.ttlDays !== 'number' || metadata.ttlDays < 0) {
-                this.errors.push(`[${name}] ttlDays must be a positive number`);
-            }
-        }
-
-        // Validate boolean flags
-        const booleanFields = ['isPage', 'isHistorical', 'isTest', 'canHaveMissingRoots', 'canHaveMissingSeries', 'isAlertComputation'];
-        for (const field of booleanFields) {
-            if (metadata[field] !== undefined && typeof metadata[field] !== 'boolean') {
-                this.errors.push(`[${name}] ${field} must be a boolean`);
-            }
-        }
-
-        // Validate series configurations
-        if (metadata.rootDataSeries) {
-            this.validateSeriesConfig(metadata.rootDataSeries, name, 'rootDataSeries');
-        }
-        
-        if (metadata.dependencySeries) {
-            this.validateSeriesConfig(metadata.dependencySeries, name, 'dependencySeries');
-        }
-    }
-
-    validateSeriesConfig(seriesConfig, name, fieldName) {
-        if (typeof seriesConfig !== 'object') {
-            this.errors.push(`[${name}] ${fieldName} must be an object`);
-            return;
-        }
-
-        for (const [key, config] of Object.entries(seriesConfig)) {
-            if (typeof config === 'number') {
-                if (config < 1 || config > 365) {
-                    this.warnings.push(`[${name}] ${fieldName}.${key} lookback of ${config} days seems unusual`);
-                }
-            } else if (typeof config === 'object') {
-                if (!config.lookback || typeof config.lookback !== 'number') {
-                    this.errors.push(`[${name}] ${fieldName}.${key} missing valid lookback property`);
-                }
-            } else {
-                this.errors.push(`[${name}] ${fieldName}.${key} must be a number or object with lookback`);
-            }
-        }
-    }
-
-    /**
-     * 3. Dependencies Validation
-     */
-    validateDependencies(dependencies, name) {
-        if (!Array.isArray(dependencies)) {
-            this.errors.push(`[${name}] getDependencies() must return an array`);
-            return;
-        }
-
-        // Check for self-dependency
-        if (dependencies.includes(name)) {
-            this.errors.push(`[${name}] Computation cannot depend on itself`);
-        }
-
-        // Warn about empty dependencies for complex calculations
-        if (dependencies.length === 0) {
-            this.warnings.push(`[${name}] No dependencies declared. Is this intentional?`);
-        }
-    }
-
-    /**
-     * 4. Code Analysis (AST-based)
-     */
-    validateCode(CalcClass, name, metadata, dependencies) {
-        const processSource = CalcClass.prototype.process.toString();
-        
-        // Parse AST
-        let ast;
-        try {
-            const wrappedSource = `class __Guard { ${processSource} }`;
-            ast = acorn.parse(wrappedSource, { ecmaVersion: 2022, sourceType: 'script' });
-        } catch (parseError) {
-            this.errors.push(`[${name}] Failed to parse process() code: ${parseError.message}`);
-            return;
-        }
-
-        // Check forbidden patterns
-        for (const { pattern, message } of VALIDATION_RULES.FORBIDDEN_PATTERNS) {
-            if (pattern.test(processSource)) {
-                this.errors.push(`[${name}] ${message}`);
-            }
-        }
-
-        // Check warning patterns
-        for (const { pattern, message } of VALIDATION_RULES.WARNING_PATTERNS) {
-            if (pattern.test(processSource)) {
-                this.warnings.push(`[${name}] ${message}`);
-            }
-        }
-
-        // AST Analysis
-        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) {
-        const allowedContext = metadata.type === 'standard' 
-            ? VALIDATION_RULES.STANDARD_CONTEXT_STRUCTURE
-            : VALIDATION_RULES.META_CONTEXT_STRUCTURE;
-
-        const usedContextProps = new Set();
-
-        walk.simple(ast, {
-            MemberExpression(node) {
-                // Check for context.PROPERTY patterns
-                if (node.object.type === 'Identifier' && node.object.name === 'context') {
-                    if (node.property.type === 'Identifier') {
-                        usedContextProps.add(node.property.name);
-                    }
-                }
-            }
-        });
-
-        // Validate used context properties
-        for (const prop of usedContextProps) {
-            if (!allowedContext.has(prop)) {
-                this.warnings.push(`[${name}] Unknown context property: context.${prop}`);
-            }
-        }
-    }
-
-    analyzeLayerUsage(ast, name) {
-        walk.simple(ast, {
-            MemberExpression(node) {
-                // Check for context.math.FUNCTION patterns
-                if (node.object.type === 'MemberExpression' &&
-                    node.object.object.type === 'Identifier' &&
-                    node.object.object.name === 'context' &&
-                    node.object.property.name === 'math') {
-                    
-                    if (node.property.type === 'Identifier') {
-                        const funcName = node.property.name;
-                        
-                        // Check if it's a known layer export
-                        if (!VALIDATION_RULES.ALLOWED_LAYER_FUNCTIONS.has(funcName)) {
-                            this.warnings.push(`[${name}] Unknown math layer function: ${funcName}`);
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    /**
-     * [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;
-
-        walk.simple(ast, {
-            ReturnStatement(node) {
-                if (node.argument !== null) hasReturn = true;
-            },
-            AssignmentExpression(node) {
-                let target = node.left;
-                while (target && target.type === 'MemberExpression') {
-                    if (target.object.type === 'ThisExpression' && 
-                        target.property.name === 'results') {
-                        assignsToResults = true;
-                        break;
-                    }
-                    target = target.object;
-                }
-            }
-        });
-
-        // Contract enforcement
-        if (metadata.type === 'meta' && !hasReturn) {
-            this.errors.push(`[${name}] Meta computation missing ReturnStatement in process()`);
-        }
-
-        if (!assignsToResults && metadata.type === 'standard') {
-            this.warnings.push(`[${name}] Standard computation never assigns to this.results`);
-        }
-    }
-
-    /**
-     * 5. Schema Validation
-     */
-    validateSchema(schema, name) {
-        if (!schema || typeof schema !== 'object') {
-            this.warnings.push(`[${name}] getSchema() should return a valid JSON Schema object`);
-            return;
-        }
-
-        // Basic schema structure check
-        if (!schema.type) {
-            this.warnings.push(`[${name}] Schema missing "type" field`);
-        }
-
-        // Check for common schema patterns
-        if (schema.type === 'object') {
-            if (!schema.properties && !schema.patternProperties) {
-                this.warnings.push(`[${name}] Object schema has no properties or patternProperties`);
-            }
-        }
-    }
-
-    /**
-     * Get validation results
-     */
-    getResults() {
-        return {
-            hasErrors: this.errors.length > 0,
-            errors: this.errors,
-            warnings: this.warnings
-        };
-    }
-
-    /**
-     * Generate formatted report
-     */
-    generateReport() {
-        const divider = '='.repeat(80);
-        const lines = [];
-
-        if (this.errors.length > 0) {
-            lines.push(`\n${divider}`);
-            lines.push(`VALIDATION ERRORS (${this.errors.length}):`);
-            this.errors.forEach((err, i) => {
-                lines.push(`  ${i + 1}. ${err}`);
-            });
-        }
-
-        if (this.warnings.length > 0) {
-            lines.push(`\n${divider}`);
-            lines.push(`VALIDATION WARNINGS (${this.warnings.length}):`);
-            this.warnings.forEach((warn, i) => {
-                lines.push(`  ${i + 1}. ${warn}`);
-            });
-        }
-
-        if (this.errors.length === 0 && this.warnings.length === 0) {
-            lines.push(`\n${divider}`);
-            lines.push('✓ ALL VALIDATIONS PASSED');
-        }
-
-        lines.push(`${divider}\n`);
-        return lines.join('\n');
-    }
-}
-
-module.exports = { ComputationValidator, VALIDATION_RULES };