typekro 0.4.0 → 0.7.0

package/dist/core/expressions/status-builder-analyzer.js

@@ -1,1311 +0,0 @@
-/**
- * Status Builder Analyzer for JavaScript to CEL Expression Conversion
- *
- * This module provides specialized analysis for status builder functions used in
- * toResourceGraph. It detects KubernetesRef objects from the magic proxy system
- * and converts JavaScript expressions to appropriate CEL expressions for status
- * field population.
- *
- * Key Features:
- * - Analyzes status builder functions for KubernetesRef detection
- * - Converts return object expressions to CEL for status field mapping
- * - Integrates with magic proxy system (SchemaProxy and ResourcesProxy)
- * - Provides status context-specific CEL generation
- * - Supports both direct and Kro factory patterns
- */
-import * as acorn from 'acorn';
-import * as estraverse from 'estraverse';
-import { ConversionError } from '../errors.js';
-import { getComponentLogger } from '../logging/index.js';
-import { containsKubernetesRefs } from '../../utils/type-guards.js';
-import { JavaScriptToCelAnalyzer } from './analyzer.js';
-import { MagicProxyAnalyzer, } from './magic-proxy-analyzer.js';
-import { SourceMapBuilder } from './source-map.js';
-import { EnhancedTypeOptionalityHandler } from './optionality-handler.js';
-import { CEL_EXPRESSION_BRAND } from '../constants/brands.js';
-/**
- * Default analysis options
- */
-const DEFAULT_ANALYSIS_OPTIONS = {
-    deepAnalysis: true,
-    includeSourceMapping: true,
-    validateReferences: true,
-    performOptionalityAnalysis: true,
-    factoryType: 'kro',
-    maxDepth: 10,
-    hydrationStates: new Map(),
-    conservativeNullSafety: true
-};
-/**
- * Status Builder Analyzer
- *
- * Analyzes status builder functions to extract KubernetesRef dependencies
- * and convert JavaScript expressions to CEL for status field population.
- */
-export class StatusBuilderAnalyzer {
-    expressionAnalyzer;
-    magicProxyAnalyzer;
-    optionalityHandler;
-    options;
-    logger = getComponentLogger('status-builder-analyzer');
-    constructor(expressionAnalyzer, options) {
-        this.expressionAnalyzer = expressionAnalyzer || new JavaScriptToCelAnalyzer();
-        this.magicProxyAnalyzer = new MagicProxyAnalyzer();
-        this.optionalityHandler = new EnhancedTypeOptionalityHandler();
-        this.options = { ...DEFAULT_ANALYSIS_OPTIONS, ...options };
-    }
-    /**
-     * Analyze status builder function for toResourceGraph integration
-     *
-     * This is the main method that analyzes a status builder function and extracts
-     * KubernetesRef dependencies for conversion to CEL expressions.
-     */
-    analyzeStatusBuilder(statusBuilder, resources, schemaProxy) {
-        try {
-            this.logger.debug('Analyzing status builder function', {
-                resourceCount: Object.keys(resources).length,
-                hasSchemaProxy: !!schemaProxy,
-                factoryType: this.options.factoryType
-            });
-            const originalSource = statusBuilder.toString();
-            // Parse the status builder function
-            const ast = this.parseStatusBuilderFunction(originalSource);
-            // Analyze the return statement
-            const returnStatement = this.analyzeReturnStatement(ast, originalSource);
-            if (!returnStatement || !returnStatement.returnsObject) {
-                throw new ConversionError('Status builder must return an object literal', originalSource, 'function-call');
-            }
-            // Analyze each property in the returned object
-            const fieldAnalysis = new Map();
-            const statusMappings = {};
-            const allDependencies = [];
-            const allSourceMap = [];
-            const allErrors = [];
-            let overallValid = true;
-            for (const property of returnStatement.properties) {
-                try {
-                    const fieldResult = this.analyzeStatusField(property, resources, originalSource, schemaProxy);
-                    fieldAnalysis.set(property.name, fieldResult);
-                    if (fieldResult.valid) {
-                        if (fieldResult.celExpression) {
-                            // For dynamic expressions, use the CEL expression directly
-                            statusMappings[property.name] = fieldResult.celExpression;
-                        }
-                        else if (fieldResult.staticValue !== undefined) {
-                            // For static objects, keep as plain JavaScript objects for performance
-                            statusMappings[property.name] = fieldResult.staticValue;
-                        }
-                        else if (property.valueNode.type === 'Literal') {
-                            // For static literals, keep as plain JavaScript values for performance
-                            statusMappings[property.name] = property.valueNode.value;
-                        }
-                        else if (property.valueNode.type === 'Identifier' && property.valueNode.name === 'undefined') {
-                            // For undefined identifier, preserve as undefined (will be filtered out during serialization)
-                            statusMappings[property.name] = undefined;
-                        }
-                        else if (property.valueNode.type === 'UnaryExpression' &&
-                            property.valueNode.operator === '!' &&
-                            property.valueNode.argument?.type === 'Literal' &&
-                            typeof property.valueNode.argument.value === 'number') {
-                            // For boolean literals represented as !0 or !1
-                            const booleanValue = property.valueNode.argument.value === 0; // !0 = true, !1 = false
-                            statusMappings[property.name] = booleanValue;
-                        }
-                    }
-                    allDependencies.push(...fieldResult.dependencies);
-                    allSourceMap.push(...fieldResult.sourceMap);
-                    allErrors.push(...fieldResult.errors);
-                    if (!fieldResult.valid) {
-                        overallValid = false;
-                    }
-                }
-                catch (error) {
-                    const fieldError = new ConversionError(`Failed to analyze status field '${property.name}': ${error instanceof Error ? error.message : String(error)}`, property.valueSource, 'unknown');
-                    allErrors.push(fieldError);
-                    overallValid = false;
-                    this.logger.debug('Status field analysis using fallback', {
-                        fieldName: property.name,
-                        reason: 'Field contains patterns that cannot be converted to CEL',
-                        fallbackBehavior: 'Static evaluation will be used',
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Categorize dependencies
-            const { resourceReferences, schemaReferences } = this.categorizeDependencies(allDependencies);
-            this.logger.debug('Status builder analysis complete', {
-                fieldCount: returnStatement.properties.length,
-                validFields: Object.keys(statusMappings).length,
-                totalDependencies: allDependencies.length,
-                resourceReferences: resourceReferences.length,
-                schemaReferences: schemaReferences.length,
-                overallValid
-            });
-            return {
-                fieldAnalysis,
-                statusMappings,
-                allDependencies,
-                resourceReferences,
-                schemaReferences,
-                sourceMap: allSourceMap,
-                errors: allErrors,
-                valid: overallValid,
-                originalSource,
-                ast,
-                returnStatement
-            };
-        }
-        catch (error) {
-            const analysisError = new ConversionError(`Failed to analyze status builder: ${error instanceof Error ? error.message : String(error)}`, statusBuilder.toString(), 'function-call');
-            this.logger.info('Status builder analysis using fallback - this is normal for certain patterns', {
-                reason: 'Status builder contains patterns that cannot be converted to CEL expressions',
-                fallbackBehavior: 'Static evaluation will be used instead',
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return {
-                fieldAnalysis: new Map(),
-                statusMappings: {},
-                allDependencies: [],
-                resourceReferences: [],
-                schemaReferences: [],
-                sourceMap: [],
-                errors: [analysisError],
-                valid: false,
-                originalSource: statusBuilder.toString()
-            };
-        }
-    }
-    /**
-     * Analyze return object expressions with magic proxy support
-     *
-     * This method analyzes the object returned by the status builder function
-     * and detects KubernetesRef objects from the magic proxy system.
-     */
-    analyzeReturnObjectWithMagicProxy(returnObject, resources, schemaProxy) {
-        const statusMappings = {};
-        const dependencies = [];
-        const errors = [];
-        if (!returnObject || typeof returnObject !== 'object') {
-            errors.push(new ConversionError('Return object must be a valid object', String(returnObject), 'unknown'));
-            return { statusMappings, dependencies, errors };
-        }
-        for (const [fieldName, fieldValue] of Object.entries(returnObject)) {
-            try {
-                const fieldResult = this.analyzeReturnObjectField(fieldName, fieldValue, resources, schemaProxy);
-                if (fieldResult.celExpression) {
-                    statusMappings[fieldName] = fieldResult.celExpression;
-                }
-                dependencies.push(...fieldResult.dependencies);
-                errors.push(...fieldResult.errors);
-            }
-            catch (error) {
-                errors.push(new ConversionError(`Failed to analyze field '${fieldName}': ${error instanceof Error ? error.message : String(error)}`, String(fieldValue), 'unknown'));
-            }
-        }
-        return { statusMappings, dependencies, errors };
-    }
-    /**
-     * Analyze a single field in the return object with comprehensive magic proxy support
-     */
-    analyzeReturnObjectField(fieldName, fieldValue, resources, schemaProxy) {
-        try {
-            // Create comprehensive analysis context
-            const context = {
-                type: 'status',
-                availableReferences: resources,
-                ...(schemaProxy && { schemaProxy }),
-                factoryType: this.options.factoryType,
-                hydrationStates: this.options.hydrationStates,
-                conservativeNullSafety: this.options.conservativeNullSafety,
-                useKroConditionals: true,
-                generateHasChecks: true,
-                maxOptionalityDepth: this.options.maxDepth,
-                dependencies: []
-            };
-            // Step 1: Detect if the field value contains KubernetesRef objects
-            const containsRefs = containsKubernetesRefs(fieldValue);
-            if (!containsRefs) {
-                // No KubernetesRef objects - return as static value
-                return {
-                    celExpression: this.convertStaticValueToCel(fieldValue),
-                    dependencies: [],
-                    errors: [],
-                    requiresConversion: false
-                };
-            }
-            // Step 2: Analyze KubernetesRef objects for optionality requirements
-            const optionalityResults = this.optionalityHandler.analyzeOptionalityRequirements(fieldValue, context);
-            // Step 3: Generate CEL expression with appropriate null-safety
-            const celResult = this.optionalityHandler.generateNullSafeCelExpression(fieldValue, optionalityResults, context);
-            // Step 4: Extract dependencies from the analysis
-            const dependencies = optionalityResults.map(result => result.kubernetesRef);
-            return {
-                celExpression: celResult.celExpression,
-                dependencies,
-                errors: celResult.errors,
-                requiresConversion: true
-            };
-        }
-        catch (error) {
-            const fieldError = new ConversionError(`Failed to analyze return object field '${fieldName}': ${error instanceof Error ? error.message : String(error)}`, String(fieldValue), 'unknown');
-            return {
-                celExpression: null,
-                dependencies: [],
-                errors: [fieldError],
-                requiresConversion: false
-            };
-        }
-    }
-    /**
-     * Convert static values (no KubernetesRef objects) to CEL expressions
-     */
-    convertStaticValueToCel(value) {
-        let celExpression;
-        let type;
-        if (typeof value === 'string') {
-            celExpression = `"${value.replace(/"/g, '\\"')}"`;
-            type = 'string';
-        }
-        else if (typeof value === 'number') {
-            celExpression = String(value);
-            type = 'number';
-        }
-        else if (typeof value === 'boolean') {
-            celExpression = String(value);
-            type = 'boolean';
-        }
-        else if (value === null) {
-            celExpression = 'null';
-            type = 'null';
-        }
-        else if (value === undefined) {
-            celExpression = 'null';
-            type = 'null';
-        }
-        else if (Array.isArray(value)) {
-            const elements = value.map(item => this.convertStaticValueToCel(item).expression);
-            celExpression = `[${elements.join(', ')}]`;
-            type = 'array';
-        }
-        else if (typeof value === 'object') {
-            const properties = Object.entries(value).map(([key, val]) => {
-                const convertedVal = this.convertStaticValueToCel(val);
-                return `"${key}": ${convertedVal.expression}`;
-            });
-            celExpression = `{${properties.join(', ')}}`;
-            type = 'object';
-        }
-        else {
-            celExpression = String(value);
-            type = 'unknown';
-        }
-        return {
-            [CEL_EXPRESSION_BRAND]: true,
-            expression: celExpression,
-            type
-        };
-    }
-    /**
-     * Perform deep analysis of nested return object structures
-     */
-    analyzeNestedReturnObjectStructure(returnObject, resources, schemaProxy, depth = 0) {
-        const flattenedMappings = {};
-        const nestedDependencies = new Map();
-        const structureErrors = [];
-        if (depth > this.options.maxDepth) {
-            structureErrors.push(new ConversionError(`Maximum analysis depth (${this.options.maxDepth}) exceeded`, String(returnObject), 'unknown'));
-            return { flattenedMappings, nestedDependencies, structureErrors };
-        }
-        try {
-            this.analyzeObjectStructureRecursively(returnObject, '', flattenedMappings, nestedDependencies, structureErrors, resources, schemaProxy, depth);
-        }
-        catch (error) {
-            structureErrors.push(new ConversionError(`Failed to analyze nested structure: ${error instanceof Error ? error.message : String(error)}`, String(returnObject), 'unknown'));
-        }
-        return { flattenedMappings, nestedDependencies, structureErrors };
-    }
-    /**
-     * Recursively analyze object structure for KubernetesRef objects
-     */
-    analyzeObjectStructureRecursively(obj, pathPrefix, flattenedMappings, nestedDependencies, errors, resources, schemaProxy, depth = 0) {
-        if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
-            return;
-        }
-        for (const [key, value] of Object.entries(obj)) {
-            const fullPath = pathPrefix ? `${pathPrefix}.${key}` : key;
-            try {
-                if (containsKubernetesRefs(value)) {
-                    // Analyze this field for KubernetesRef objects
-                    const fieldResult = this.analyzeReturnObjectField(fullPath, value, resources, schemaProxy);
-                    if (fieldResult.celExpression) {
-                        flattenedMappings[fullPath] = fieldResult.celExpression;
-                    }
-                    if (fieldResult.dependencies.length > 0) {
-                        nestedDependencies.set(fullPath, fieldResult.dependencies);
-                    }
-                    errors.push(...fieldResult.errors);
-                }
-                else if (value && typeof value === 'object' && !Array.isArray(value)) {
-                    // Recursively analyze nested objects
-                    this.analyzeObjectStructureRecursively(value, fullPath, flattenedMappings, nestedDependencies, errors, resources, schemaProxy, depth + 1);
-                }
-                else {
-                    // Static value - convert directly
-                    flattenedMappings[fullPath] = this.convertStaticValueToCel(value);
-                }
-            }
-            catch (error) {
-                errors.push(new ConversionError(`Failed to analyze nested field '${fullPath}': ${error instanceof Error ? error.message : String(error)}`, String(value), 'unknown'));
-            }
-        }
-    }
-    /**
-     * Generate status context-specific CEL from KubernetesRef objects
-     *
-     * This method generates CEL expressions specifically for status context,
-     * taking into account the magic proxy system and field hydration timing.
-     */
-    generateStatusContextCel(kubernetesRef, context) {
-        try {
-            return this.generateStatusContextCelWithAdvancedFeatures(kubernetesRef, context);
-        }
-        catch (error) {
-            this.logger.debug('Status context CEL generation using fallback', {
-                resourceId: kubernetesRef.resourceId,
-                fieldPath: kubernetesRef.fieldPath,
-                reason: 'Reference pattern cannot be converted to CEL',
-                fallbackBehavior: 'Static reference will be used',
-                error: error instanceof Error ? error.message : String(error)
-            });
-            // Return a safe fallback
-            return this.generateFallbackStatusCel(kubernetesRef);
-        }
-    }
-    /**
-     * Generate advanced status context CEL with full feature support
-     */
-    generateStatusContextCelWithAdvancedFeatures(kubernetesRef, context) {
-        const isSchemaRef = kubernetesRef.resourceId === '__schema__';
-        const fieldPath = kubernetesRef.fieldPath || '';
-        // Build base CEL expression
-        let baseCelExpression;
-        if (isSchemaRef) {
-            baseCelExpression = `schema.${fieldPath}`;
-        }
-        else {
-            baseCelExpression = `resources.${kubernetesRef.resourceId}.${fieldPath}`;
-        }
-        // Determine status-specific handling requirements
-        const statusHandlingInfo = this.analyzeStatusFieldHandlingRequirements(kubernetesRef, context);
-        // Apply status-specific transformations
-        const finalExpression = this.applyStatusContextTransformations(baseCelExpression, statusHandlingInfo, context);
-        // Infer the result type based on the field path and context
-        const resultType = this.inferStatusFieldType(kubernetesRef, context);
-        return {
-            [CEL_EXPRESSION_BRAND]: true,
-            expression: finalExpression,
-            type: resultType,
-            metadata: {
-                isStatusContext: true,
-                requiresHydration: statusHandlingInfo.requiresHydration,
-                isOptional: statusHandlingInfo.isOptional,
-                handlingStrategy: statusHandlingInfo.strategy
-            }
-        };
-    }
-    /**
-     * Analyze status field handling requirements
-     */
-    analyzeStatusFieldHandlingRequirements(kubernetesRef, context) {
-        const fieldPath = kubernetesRef.fieldPath || '';
-        const isSchemaRef = kubernetesRef.resourceId === '__schema__';
-        const isStatusField = fieldPath.startsWith('status.');
-        // Determine if this field requires hydration
-        const requiresHydration = !isSchemaRef && isStatusField;
-        // Determine if this field is optional in status context
-        const isOptional = this.isFieldOptionalInStatusContext(kubernetesRef, context);
-        // Determine handling strategy
-        let strategy;
-        if (requiresHydration && isOptional) {
-            strategy = 'hydration-with-null-safety';
-        }
-        else if (requiresHydration) {
-            strategy = 'hydration-required';
-        }
-        else if (isOptional) {
-            strategy = 'null-safety-only';
-        }
-        else {
-            strategy = 'direct-access';
-        }
-        // Determine priority for status field evaluation
-        const priority = this.calculateStatusFieldPriority(kubernetesRef, context);
-        return {
-            kubernetesRef,
-            requiresHydration,
-            isOptional,
-            strategy,
-            priority,
-            fieldCategory: this.categorizeStatusField(fieldPath),
-            expectedAvailability: this.estimateFieldAvailability(kubernetesRef, context)
-        };
-    }
-    /**
-     * Apply status context-specific transformations to CEL expression
-     */
-    applyStatusContextTransformations(baseCelExpression, handlingInfo, context) {
-        let transformedExpression = baseCelExpression;
-        switch (handlingInfo.strategy) {
-            case 'hydration-with-null-safety':
-                transformedExpression = this.applyHydrationWithNullSafety(baseCelExpression, handlingInfo, context);
-                break;
-            case 'hydration-required':
-                transformedExpression = this.applyHydrationRequired(baseCelExpression, handlingInfo, context);
-                break;
-            case 'null-safety-only':
-                transformedExpression = this.applyNullSafetyOnly(baseCelExpression, handlingInfo, context);
-                break;
-            case 'direct-access':
-                // No transformation needed
-                break;
-        }
-        return transformedExpression;
-    }
-    /**
-     * Apply hydration with null-safety transformation
-     */
-    applyHydrationWithNullSafety(baseCelExpression, _handlingInfo, context) {
-        if (context.useKroConditionals) {
-            // Use Kro's conditional operators
-            return baseCelExpression.replace(/\./g, '?.');
-        }
-        else if (context.generateHasChecks) {
-            // Use has() checks
-            const pathParts = baseCelExpression.split('.');
-            const hasChecks = [];
-            for (let i = 0; i < pathParts.length; i++) {
-                const partialPath = pathParts.slice(0, i + 1).join('.');
-                hasChecks.push(`has(${partialPath})`);
-            }
-            return `${hasChecks.join(' && ')} && ${baseCelExpression}`;
-        }
-        return baseCelExpression;
-    }
-    /**
-     * Apply hydration required transformation
-     */
-    applyHydrationRequired(baseCelExpression, handlingInfo, _context) {
-        // For hydration required fields, we might want to add readiness checks
-        if (handlingInfo.fieldCategory === 'readiness-indicator') {
-            return `${baseCelExpression} != null && ${baseCelExpression}`;
-        }
-        return baseCelExpression;
-    }
-    /**
-     * Apply null-safety only transformation
-     */
-    applyNullSafetyOnly(baseCelExpression, _handlingInfo, context) {
-        if (context.generateHasChecks) {
-            return `has(${baseCelExpression}) && ${baseCelExpression}`;
-        }
-        return baseCelExpression;
-    }
-    /**
-     * Check if a field is optional in status context
-     */
-    isFieldOptionalInStatusContext(kubernetesRef, _context) {
-        const fieldPath = kubernetesRef.fieldPath || '';
-        // Status fields are generally optional during hydration
-        if (fieldPath.startsWith('status.')) {
-            return true;
-        }
-        // Some spec fields might be optional
-        const optionalSpecFields = [
-            'spec.replicas',
-            'spec.resources',
-            'spec.nodeSelector',
-            'spec.tolerations'
-        ];
-        if (optionalSpecFields.some(field => fieldPath.startsWith(field))) {
-            return true;
-        }
-        // Metadata fields like labels and annotations are optional
-        const optionalMetadataFields = [
-            'metadata.labels',
-            'metadata.annotations',
-            'metadata.namespace'
-        ];
-        if (optionalMetadataFields.some(field => fieldPath.startsWith(field))) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Calculate priority for status field evaluation
-     */
-    calculateStatusFieldPriority(kubernetesRef, _context) {
-        const fieldPath = kubernetesRef.fieldPath || '';
-        // Higher priority (lower number) for critical status fields
-        if (fieldPath.includes('ready') || fieldPath.includes('available')) {
-            return 1;
-        }
-        if (fieldPath.startsWith('status.conditions')) {
-            return 2;
-        }
-        if (fieldPath.startsWith('status.')) {
-            return 3;
-        }
-        if (fieldPath.startsWith('spec.')) {
-            return 4;
-        }
-        if (fieldPath.startsWith('metadata.')) {
-            return 5;
-        }
-        return 10; // Default priority
-    }
-    /**
-     * Categorize status field type
-     */
-    categorizeStatusField(fieldPath) {
-        if (fieldPath.includes('ready') || fieldPath.includes('available')) {
-            return 'readiness-indicator';
-        }
-        if (fieldPath.includes('conditions')) {
-            return 'condition-status';
-        }
-        if (fieldPath.includes('replicas')) {
-            return 'replica-status';
-        }
-        if (fieldPath.includes('loadBalancer') || fieldPath.includes('ingress')) {
-            return 'network-status';
-        }
-        if (fieldPath.includes('phase') || fieldPath.includes('state')) {
-            return 'lifecycle-status';
-        }
-        return 'general-status';
-    }
-    /**
-     * Estimate field availability timing
-     */
-    estimateFieldAvailability(kubernetesRef, _context) {
-        const fieldPath = kubernetesRef.fieldPath || '';
-        if (kubernetesRef.resourceId === '__schema__') {
-            return 'immediate';
-        }
-        if (fieldPath.startsWith('metadata.')) {
-            return 'immediate';
-        }
-        if (fieldPath.startsWith('spec.')) {
-            return 'immediate';
-        }
-        if (fieldPath.includes('ready') || fieldPath.includes('available')) {
-            return 'delayed';
-        }
-        if (fieldPath.includes('loadBalancer') || fieldPath.includes('ingress')) {
-            return 'very-delayed';
-        }
-        return 'delayed';
-    }
-    /**
-     * Infer the type of a status field
-     */
-    inferStatusFieldType(kubernetesRef, _context) {
-        const fieldPath = kubernetesRef.fieldPath || '';
-        if (fieldPath.includes('replicas') || fieldPath.includes('count')) {
-            return 'number';
-        }
-        if (fieldPath.includes('ready') || fieldPath.includes('available')) {
-            return 'boolean';
-        }
-        if (fieldPath.includes('conditions')) {
-            return 'array';
-        }
-        if (fieldPath.includes('phase') || fieldPath.includes('state')) {
-            return 'string';
-        }
-        if (fieldPath.includes('ip') || fieldPath.includes('IP')) {
-            return 'string';
-        }
-        return 'unknown';
-    }
-    /**
-     * Analyze a mixed object expression (contains both static and dynamic values)
-     */
-    analyzeMixedObjectExpression(objectNode, resources, originalSource, schemaProxy) {
-        if (objectNode.type !== 'ObjectExpression') {
-            return { valid: false, processedObject: null, dependencies: [], requiresConversion: false };
-        }
-        const result = {};
-        const allDependencies = [];
-        let requiresConversion = false;
-        for (const prop of objectNode.properties) {
-            if (prop.type === 'Property' && prop.key.type === 'Identifier') {
-                const key = prop.key.name;
-                // Handle different value types
-                if (prop.value.type === 'Literal') {
-                    // Static literal value
-                    result[key] = prop.value.value;
-                }
-                else if (prop.value.type === 'ObjectExpression') {
-                    // Nested object - recursively analyze
-                    const nestedResult = this.analyzeMixedObjectExpression(prop.value, resources, originalSource, schemaProxy);
-                    if (nestedResult.valid) {
-                        result[key] = nestedResult.processedObject;
-                        allDependencies.push(...nestedResult.dependencies);
-                        if (nestedResult.requiresConversion) {
-                            requiresConversion = true;
-                        }
-                    }
-                    else {
-                        return { valid: false, processedObject: null, dependencies: [], requiresConversion: false };
-                    }
-                }
-                else {
-                    // Dynamic expression - analyze with expression analyzer
-                    let valueSource;
-                    try {
-                        valueSource = this.getNodeSource(prop.value, originalSource);
-                    }
-                    catch (_error) {
-                        return { valid: false, processedObject: null, dependencies: [], requiresConversion: false };
-                    }
-                    // Create analysis context
-                    const context = {
-                        type: 'status',
-                        availableReferences: resources,
-                        ...(schemaProxy && { schemaProxy }),
-                        factoryType: this.options.factoryType,
-                        dependencies: []
-                    };
-                    try {
-                        // Analyze the expression using the main analyzer
-                        const analysisResult = this.expressionAnalyzer.analyzeExpression(valueSource, context);
-                        if (analysisResult.valid && analysisResult.celExpression) {
-                            // Dynamic expression - wrap in CEL
-                            const celString = analysisResult.celExpression.expression;
-                            result[key] = celString.includes('${') ? celString : `\${${celString}}`;
-                            allDependencies.push(...analysisResult.dependencies);
-                            requiresConversion = true;
-                        }
-                        else {
-                            // Try to evaluate as static value
-                            const staticValue = this.evaluateStaticValue(prop.value);
-                            if (staticValue !== null) {
-                                result[key] = staticValue;
-                            }
-                            else {
-                                return { valid: false, processedObject: null, dependencies: [], requiresConversion: false };
-                            }
-                        }
-                    }
-                    catch (error) {
-                        // If expression analysis fails, try static evaluation
-                        const staticValue = this.evaluateStaticValue(prop.value);
-                        if (staticValue !== null) {
-                            result[key] = staticValue;
-                        }
-                        else {
-                            console.log(`Failed to analyze property '${key}' of type '${prop.value.type}':`, error);
-                            return { valid: false, processedObject: null, dependencies: [], requiresConversion: false };
-                        }
-                    }
-                }
-            }
-            else {
-                // Non-standard property structure
-                return { valid: false, processedObject: null, dependencies: [], requiresConversion: false };
-            }
-        }
-        return {
-            valid: true,
-            processedObject: result,
-            dependencies: allDependencies,
-            requiresConversion
-        };
-    }
-    /**
-     * Evaluate a static object expression to a JavaScript object
-     */
-    evaluateStaticObjectExpression(objectNode) {
-        if (objectNode.type !== 'ObjectExpression') {
-            return null;
-        }
-        const result = {};
-        for (const prop of objectNode.properties) {
-            if (prop.type === 'Property' && prop.key.type === 'Identifier') {
-                const key = prop.key.name;
-                const value = this.evaluateStaticValue(prop.value);
-                if (value === null && prop.value.type !== 'Literal') {
-                    // If we can't evaluate a property statically, this isn't a static object
-                    return null;
-                }
-                result[key] = value;
-            }
-            else {
-                // Non-static property structure
-                return null;
-            }
-        }
-        return result;
-    }
-    /**
-     * Evaluate a static value from an AST node
-     */
-    evaluateStaticValue(node) {
-        switch (node.type) {
-            case 'Literal':
-                return node.value;
-            case 'UnaryExpression':
-                if (node.operator === '!' && node.argument?.type === 'Literal') {
-                    return !node.argument.value;
-                }
-                if (node.operator === '-' && node.argument?.type === 'Literal' && typeof node.argument.value === 'number') {
-                    return -node.argument.value;
-                }
-                return null;
-            case 'ObjectExpression':
-                return this.evaluateStaticObjectExpression(node);
-            case 'ArrayExpression': {
-                const arrayResult = [];
-                for (const element of node.elements) {
-                    if (element === null) {
-                        arrayResult.push(null);
-                    }
-                    else {
-                        const elementValue = this.evaluateStaticValue(element);
-                        if (elementValue === null && element.type !== 'Literal') {
-                            return null; // Non-static array
-                        }
-                        arrayResult.push(elementValue);
-                    }
-                }
-                return arrayResult;
-            }
-            default:
-                return null; // Non-static value
-        }
-    }
-    /**
-     * Create a CelExpression for a static value
-     */
-    createStaticCelExpression(value) {
-        return {
-            [CEL_EXPRESSION_BRAND]: true,
-            expression: value
-        };
-    }
-    /**
-     * Extract source code for an AST node using range information
-     */
-    getNodeSource(node, originalSource) {
-        if (!node || !node.type) {
-            return '';
-        }
-        // Try to use range information to extract the actual source
-        let start;
-        let end;
-        // Check for start/end properties (acorn format)
-        if (typeof node.start === 'number' && typeof node.end === 'number') {
-            start = node.start;
-            end = node.end;
-        }
-        // Check for range array (alternative format)
-        else if (Array.isArray(node.range) && node.range.length === 2) {
-            start = node.range[0];
-            end = node.range[1];
-        }
-        // If we have valid range information, extract the source
-        if (typeof start === 'number' && typeof end === 'number' &&
-            start >= 0 && end <= originalSource.length && start <= end) {
-            const extracted = originalSource.slice(start, end).trim();
-            if (extracted.length > 0) {
-                return extracted;
-            }
-        }
-        // Fallback to manual reconstruction for specific node types
-        switch (node.type) {
-            case 'Literal':
-                return typeof node.value === 'string' ? `"${node.value}"` : String(node.value);
-            case 'Identifier':
-                return node.name;
-            case 'BinaryExpression': {
-                const left = this.getNodeSource(node.left, originalSource);
-                const right = this.getNodeSource(node.right, originalSource);
-                return `${left} ${node.operator} ${right}`;
-            }
-            case 'MemberExpression': {
-                const object = this.getNodeSource(node.object, originalSource);
-                if (node.computed) {
-                    return `${object}[${this.getNodeSource(node.property, originalSource)}]`;
-                }
-                else {
-                    const propertyName = node.property.name || this.getNodeSource(node.property, originalSource);
-                    return `${object}.${propertyName}`;
-                }
-            }
-            case 'ConditionalExpression':
-                return `${this.getNodeSource(node.test, originalSource)} ? ${this.getNodeSource(node.consequent, originalSource)} : ${this.getNodeSource(node.alternate, originalSource)}`;
-            case 'LogicalExpression':
-                return `${this.getNodeSource(node.left, originalSource)} ${node.operator} ${this.getNodeSource(node.right, originalSource)}`;
-            case 'CallExpression': {
-                const callee = this.getNodeSource(node.callee, originalSource);
-                const args = node.arguments.map((arg) => this.getNodeSource(arg, originalSource)).join(', ');
-                return `${callee}(${args})`;
-            }
-            case 'ArrowFunctionExpression': {
-                const params = node.params.map((param) => param.name).join(', ');
-                const body = this.getNodeSource(node.body, originalSource);
-                return `(${params}) => ${body}`;
-            }
-            case 'TemplateLiteral': {
-                // Simplified template literal reconstruction
-                let result = '`';
-                for (let i = 0; i < node.quasis.length; i++) {
-                    const quasi = node.quasis[i];
-                    result += quasi?.value?.raw || quasi?.value?.cooked || '';
-                    if (i < node.expressions.length) {
-                        result += `\${${this.getNodeSource(node.expressions[i], originalSource)}}`;
-                    }
-                }
-                result += '`';
-                return result;
-            }
-            default:
-                // Fallback - return a placeholder
-                return `<${node.type}>`;
-        }
-    }
-    /**
-     * Generate fallback status CEL expression
-     */
-    generateFallbackStatusCel(kubernetesRef) {
-        const isSchemaRef = kubernetesRef.resourceId === '__schema__';
-        const basePath = isSchemaRef
-            ? `schema.${kubernetesRef.fieldPath}`
-            : `resources.${kubernetesRef.resourceId}.${kubernetesRef.fieldPath}`;
-        return {
-            [CEL_EXPRESSION_BRAND]: true,
-            expression: basePath,
-            type: 'unknown'
-        };
-    }
-    /**
-     * Parse status builder function to AST
-     */
-    parseStatusBuilderFunction(source) {
-        try {
-            // Parse the function source with modern JavaScript support using acorn
-            const ast = acorn.parse(source, {
-                ecmaVersion: 2022, // Support modern JavaScript features including optional chaining
-                sourceType: 'script',
-                locations: true,
-                ranges: true
-            });
-            return ast;
-        }
-        catch (error) {
-            throw new ConversionError(`Failed to parse status builder function: ${error instanceof Error ? error.message : String(error)}`, source, 'javascript');
-        }
-    }
-    /**
-     * Analyze the return statement of the status builder
-     */
-    analyzeReturnStatement(ast, originalSource) {
-        let foundReturnStatement = null;
-        let foundArrowFunction = null;
-        // Find the return statement or arrow function with implicit return
-        estraverse.traverse(ast, {
-            enter: (node) => {
-                if (node.type === 'ReturnStatement') {
-                    foundReturnStatement = node;
-                    return estraverse.VisitorOption.Break;
-                }
-                if (node.type === 'ArrowFunctionExpression' && node.body?.type === 'ObjectExpression') {
-                    foundArrowFunction = node;
-                    return estraverse.VisitorOption.Break;
-                }
-                return undefined;
-            }
-        });
-        // Handle explicit return statement
-        if (foundReturnStatement) {
-            const returnStatement = foundReturnStatement;
-            // Check if it returns an object expression
-            const returnsObject = returnStatement.argument?.type === 'ObjectExpression';
-            if (!returnsObject) {
-                return {
-                    node: returnStatement,
-                    returnsObject: false,
-                    properties: [],
-                    sourceLocation: {
-                        line: returnStatement.loc?.start.line || 0,
-                        column: returnStatement.loc?.start.column || 0,
-                        length: 0
-                    }
-                };
-            }
-            // Analyze properties in the object expression
-            const objectExpression = returnStatement.argument;
-            const properties = this.analyzeObjectProperties(objectExpression, originalSource);
-            return {
-                node: returnStatement,
-                returnsObject: true,
-                properties,
-                sourceLocation: {
-                    line: returnStatement.loc?.start.line || 0,
-                    column: returnStatement.loc?.start.column || 0,
-                    length: returnStatement.range ? returnStatement.range[1] - returnStatement.range[0] : 0
-                }
-            };
-        }
-        // Handle arrow function with implicit return
-        if (foundArrowFunction && foundArrowFunction.body?.type === 'ObjectExpression') {
-            const objectExpression = foundArrowFunction.body;
-            const properties = this.analyzeObjectProperties(objectExpression, originalSource);
-            return {
-                node: foundArrowFunction,
-                returnsObject: true,
-                properties,
-                sourceLocation: {
-                    line: objectExpression.loc?.start.line || 0,
-                    column: objectExpression.loc?.start.column || 0,
-                    length: objectExpression.range ? objectExpression.range[1] - objectExpression.range[0] : 0
-                }
-            };
-        }
-        return null;
-    }
-    /**
-     * Analyze properties in an object expression
-     */
-    analyzeObjectProperties(objectExpression, originalSource) {
-        const properties = [];
-        for (const prop of objectExpression.properties) {
-            if (prop.type === 'Property' && prop.key.type === 'Identifier') {
-                const propertyAnalysis = {
-                    name: prop.key.name,
-                    valueNode: prop.value,
-                    valueSource: this.getNodeSource(prop.value, originalSource),
-                    containsKubernetesRefs: false, // Will be determined during field analysis
-                    sourceLocation: {
-                        line: prop.loc?.start.line || 0,
-                        column: prop.loc?.start.column || 0,
-                        length: prop.range ? prop.range[1] - prop.range[0] : 0
-                    }
-                };
-                properties.push(propertyAnalysis);
-            }
-        }
-        return properties;
-    }
-    /**
-     * Analyze a single status field
-     */
-    analyzeStatusField(property, resources, originalSource, schemaProxy) {
-        const fieldName = property.name;
-        const originalExpression = property.valueSource;
-        try {
-            // Check if this is a static literal value
-            if (property.valueNode.type === 'Literal') {
-                // Static literal - return as-is without CEL conversion
-                return {
-                    fieldName,
-                    originalExpression,
-                    celExpression: null,
-                    dependencies: [],
-                    requiresConversion: false,
-                    valid: true,
-                    errors: [],
-                    sourceMap: [],
-                    optionalityAnalysis: [],
-                    inferredType: typeof property.valueNode.value,
-                    confidence: 1.0
-                };
-            }
-            // Check if this is the 'undefined' identifier (special case)
-            if (property.valueNode.type === 'Identifier' && property.valueNode.name === 'undefined') {
-                // undefined identifier - return as-is without CEL conversion
-                return {
-                    fieldName,
-                    originalExpression,
-                    celExpression: null,
-                    dependencies: [],
-                    requiresConversion: false,
-                    valid: true,
-                    errors: [],
-                    sourceMap: [],
-                    optionalityAnalysis: [],
-                    inferredType: 'undefined',
-                    confidence: 1.0
-                };
-            }
-            // Check if this is a boolean literal represented as UnaryExpression (!0 for true, !1 for false)
-            if (property.valueNode.type === 'UnaryExpression' &&
-                property.valueNode.operator === '!' &&
-                property.valueNode.argument?.type === 'Literal' &&
-                typeof property.valueNode.argument.value === 'number') {
-                const _booleanValue = property.valueNode.argument.value === 0; // !0 = true, !1 = false
-                return {
-                    fieldName,
-                    originalExpression,
-                    celExpression: null,
-                    dependencies: [],
-                    requiresConversion: false,
-                    valid: true,
-                    errors: [],
-                    sourceMap: [],
-                    optionalityAnalysis: [],
-                    inferredType: 'boolean',
-                    confidence: 1.0
-                };
-            }
-            // Check if this is a static object expression
-            if (property.valueNode.type === 'ObjectExpression') {
-                // Try to evaluate the object as a static value
-                const staticValue = this.evaluateStaticObjectExpression(property.valueNode);
-                if (staticValue !== null) {
-                    return {
-                        fieldName,
-                        originalExpression,
-                        celExpression: null,
-                        dependencies: [],
-                        requiresConversion: false,
-                        valid: true,
-                        errors: [],
-                        sourceMap: [],
-                        optionalityAnalysis: [],
-                        inferredType: 'object',
-                        confidence: 1.0,
-                        staticValue // Store the evaluated static value
-                    };
-                }
-                else {
-                    // This is a mixed object (contains both static and dynamic values)
-                    // Recursively analyze each property
-                    const mixedObjectResult = this.analyzeMixedObjectExpression(property.valueNode, resources, originalSource, schemaProxy);
-                    if (mixedObjectResult.valid) {
-                        return {
-                            fieldName,
-                            originalExpression,
-                            celExpression: null,
-                            dependencies: mixedObjectResult.dependencies,
-                            requiresConversion: mixedObjectResult.requiresConversion,
-                            valid: true,
-                            errors: [],
-                            sourceMap: [],
-                            optionalityAnalysis: [],
-                            inferredType: 'object',
-                            confidence: 1.0,
-                            staticValue: mixedObjectResult.processedObject
-                        };
-                    }
-                    else {
-                        // Mixed object analysis failed, return error
-                        return {
-                            fieldName,
-                            originalExpression,
-                            celExpression: null,
-                            dependencies: [],
-                            requiresConversion: false,
-                            valid: false,
-                            errors: [new ConversionError(`Failed to analyze mixed object expression for field '${fieldName}'`, originalExpression, 'unknown')],
-                            sourceMap: [],
-                            optionalityAnalysis: [],
-                            inferredType: 'object',
-                            confidence: 0.0
-                        };
-                    }
-                }
-            }
-            // Create analysis context
-            const context = {
-                type: 'status',
-                availableReferences: resources,
-                ...(schemaProxy && { schemaProxy }),
-                factoryType: this.options.factoryType,
-                ...(this.options.includeSourceMapping && { sourceMap: new SourceMapBuilder() }),
-                dependencies: []
-            };
-            // Analyze the expression using the main analyzer
-            const analysisResult = this.expressionAnalyzer.analyzeExpression(originalExpression, context);
-            // Perform optionality analysis if enabled
-            let optionalityAnalysis = [];
-            if (this.options.performOptionalityAnalysis) {
-                const optionalityContext = {
-                    ...context,
-                    hydrationStates: this.options.hydrationStates,
-                    conservativeNullSafety: this.options.conservativeNullSafety,
-                    useKroConditionals: true,
-                    generateHasChecks: true
-                };
-                optionalityAnalysis = this.optionalityHandler.analyzeOptionalityRequirements(originalExpression, optionalityContext);
-            }
-            return {
-                fieldName,
-                originalExpression,
-                celExpression: analysisResult.celExpression,
-                dependencies: analysisResult.dependencies,
-                requiresConversion: analysisResult.requiresConversion,
-                valid: analysisResult.valid,
-                errors: analysisResult.errors,
-                sourceMap: analysisResult.sourceMap,
-                optionalityAnalysis,
-                inferredType: analysisResult.inferredType ? String(analysisResult.inferredType) : undefined,
-                confidence: this.calculateFieldConfidence(analysisResult, optionalityAnalysis)
-            };
-        }
-        catch (error) {
-            const fieldError = new ConversionError(`Failed to analyze field '${fieldName}': ${error instanceof Error ? error.message : String(error)}`, originalExpression, 'unknown');
-            return {
-                fieldName,
-                originalExpression,
-                celExpression: null,
-                dependencies: [],
-                requiresConversion: false,
-                valid: false,
-                errors: [fieldError],
-                sourceMap: [],
-                optionalityAnalysis: [],
-                inferredType: undefined,
-                confidence: 0
-            };
-        }
-    }
-    /**
-     * Calculate confidence level for field analysis
-     */
-    calculateFieldConfidence(analysisResult, optionalityAnalysis) {
-        let confidence = 0.8; // Base confidence
-        if (analysisResult.valid) {
-            confidence += 0.1;
-        }
-        if (analysisResult.errors.length === 0) {
-            confidence += 0.1;
-        }
-        // Factor in optionality analysis confidence
-        if (optionalityAnalysis.length > 0) {
-            const avgOptionalityConfidence = optionalityAnalysis.reduce((sum, result) => sum + result.confidence, 0) / optionalityAnalysis.length;
-            confidence = (confidence + avgOptionalityConfidence) / 2;
-        }
-        return Math.max(0, Math.min(1, confidence));
-    }
-    /**
-     * Categorize dependencies into resource and schema references
-     */
-    categorizeDependencies(dependencies) {
-        const resourceReferences = [];
-        const schemaReferences = [];
-        for (const dep of dependencies) {
-            if (dep.resourceId === '__schema__') {
-                schemaReferences.push(dep);
-            }
-            else {
-                resourceReferences.push(dep);
-            }
-        }
-        return { resourceReferences, schemaReferences };
-    }
-}
-/**
- * Analyze status builder function for toResourceGraph integration with KubernetesRef detection
- *
- * This is the main integration point for toResourceGraph to analyze status builder functions
- * and detect KubernetesRef objects from the magic proxy system.
- */
-export function analyzeStatusBuilderForToResourceGraph(statusBuilder, resources, schemaProxy, factoryType = 'kro') {
-    const options = {
-        deepAnalysis: true,
-        includeSourceMapping: true,
-        validateReferences: true,
-        performOptionalityAnalysis: true,
-        factoryType,
-        conservativeNullSafety: true
-    };
-    const analyzer = new StatusBuilderAnalyzer(undefined, options);
-    const result = analyzer.analyzeStatusBuilder(statusBuilder, resources, schemaProxy);
-    // Calculate hydration order based on dependencies
-    const hydrationOrder = calculateStatusFieldHydrationOrder(result.fieldAnalysis);
-    // Determine if any conversion is required
-    const requiresConversion = Array.from(result.fieldAnalysis.values()).some(field => field.requiresConversion);
-    return {
-        statusMappings: result.statusMappings,
-        dependencies: result.allDependencies,
-        hydrationOrder,
-        errors: result.errors,
-        valid: result.valid,
-        requiresConversion
-    };
-}
-/**
- * Calculate hydration order for status fields based on their dependencies
- */
-function calculateStatusFieldHydrationOrder(fieldAnalysis) {
-    const fieldDependencies = new Map();
-    const allFields = Array.from(fieldAnalysis.keys());
-    // Build field-to-field dependencies
-    for (const [fieldName, analysis] of fieldAnalysis) {
-        const fieldDeps = new Set();
-        // For each KubernetesRef dependency, find other fields that might provide that data
-        for (const dep of analysis.dependencies) {
-            if (dep.resourceId !== '__schema__') {
-                // Find fields that reference the same resource
-                for (const [otherField, otherAnalysis] of fieldAnalysis) {
-                    if (otherField !== fieldName) {
-                        const hasMatchingResource = otherAnalysis.dependencies.some(otherDep => otherDep.resourceId === dep.resourceId);
-                        if (hasMatchingResource) {
-                            fieldDeps.add(otherField);
-                        }
-                    }
-                }
-            }
-        }
-        fieldDependencies.set(fieldName, fieldDeps);
-    }
-    // Perform topological sort
-    const visited = new Set();
-    const visiting = new Set();
-    const result = [];
-    const visit = (field) => {
-        if (visiting.has(field)) {
-            // Circular dependency - add to result anyway
-            return;
-        }
-        if (visited.has(field)) {
-            return;
-        }
-        visiting.add(field);
-        const deps = fieldDependencies.get(field) || new Set();
-        for (const dep of deps) {
-            visit(dep);
-        }
-        visiting.delete(field);
-        visited.add(field);
-        result.push(field);
-    };
-    for (const field of allFields) {
-        visit(field);
-    }
-    return result;
-}
-/**
- * Convenience function to analyze status builder functions
- */
-export function analyzeStatusBuilder(statusBuilder, resources, schemaProxy, options) {
-    const analyzer = new StatusBuilderAnalyzer(undefined, options);
-    return analyzer.analyzeStatusBuilder(statusBuilder, resources, schemaProxy);
-}
-/**
- * Convenience function to analyze return objects with magic proxy support
- */
-export function analyzeReturnObjectWithMagicProxy(returnObject, resources, schemaProxy, options) {
-    const analyzer = new StatusBuilderAnalyzer(undefined, options);
-    return analyzer.analyzeReturnObjectWithMagicProxy(returnObject, resources, schemaProxy);
-}
-/**
- * Convenience function to generate status context-specific CEL
- */
-export function generateStatusContextCel(kubernetesRef, context, options) {
-    const analyzer = new StatusBuilderAnalyzer(undefined, options);
-    return analyzer.generateStatusContextCel(kubernetesRef, context);
-}
-//# sourceMappingURL=status-builder-analyzer.js.map