typekro 0.2.2 → 0.3.0

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

@@ -0,0 +1,1301 @@
+/**
+ * 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.error('Failed to analyze status field', error, {
+                        fieldName: property.name
+                    });
+                }
+            }
+            // 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.error('Status builder analysis failed', 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.error('Failed to generate status context CEL', error, {
+                resourceId: kubernetesRef.resourceId,
+                fieldPath: kubernetesRef.fieldPath
+            });
+            // 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