typekro 0.2.1 → 0.3.0

package/dist/core/expressions/resource-analyzer.js

@@ -0,0 +1,1086 @@
+/**
+ * Resource Builder Integration for JavaScript to CEL Expression Conversion
+ *
+ * This module provides integration with TypeKro's existing KubernetesRef and magic proxy systems
+ * for analyzing resource configurations that contain JavaScript expressions with KubernetesRef objects.
+ *
+ * The analyzer detects when resource builders use expressions that depend on other resources
+ * and converts them to appropriate CEL expressions based on the factory pattern.
+ */
+import { containsKubernetesRefs, isKubernetesRef } from '../../utils/type-guards.js';
+import { ConversionError } from '../errors.js';
+import { JavaScriptToCelAnalyzer, } from './analyzer.js';
+import { SourceMapBuilder } from './source-map.js';
+/**
+ * Analyzes resource configurations for JavaScript expressions containing KubernetesRef objects
+ */
+export class ResourceAnalyzer {
+    analyzer;
+    dependencyTracker;
+    typeValidator;
+    constructor() {
+        this.analyzer = new JavaScriptToCelAnalyzer();
+        this.dependencyTracker = new DependencyTracker();
+        this.typeValidator = new ResourceTypeValidator();
+    }
+    /**
+     * Analyze a resource configuration for KubernetesRef-dependent expressions
+     * This is the main entry point for resource builder integration
+     */
+    analyzeResourceConfig(resourceId, config, context) {
+        const result = {
+            originalConfig: config,
+            processedConfig: {},
+            dependencies: [],
+            convertedFields: [],
+            errors: [],
+            requiresConversion: false,
+            circularDependencies: [],
+            typeValidationResults: []
+        };
+        try {
+            // Deep analyze the configuration object
+            result.processedConfig = this.analyzeConfigObject(config, '', context, result);
+            // Track dependencies automatically
+            const _dependencyInfos = this.dependencyTracker.trackDependencies(resourceId, result.dependencies, result.convertedFields, {
+                trackSchemaDependencies: true,
+                trackResourceDependencies: true,
+                trackExternalDependencies: true,
+                detectCircularDependencies: true,
+                computeDeploymentOrder: true
+            });
+            // Get circular dependencies from tracker
+            result.circularDependencies = this.dependencyTracker.getDependencyGraph().circularChains;
+            // Validate resource types if requested
+            if (context.validateResourceTypes) {
+                result.typeValidationResults = this.validateResourceTypes(result.dependencies, context);
+            }
+            // Set overall conversion flag
+            result.requiresConversion = result.convertedFields.length > 0;
+        }
+        catch (error) {
+            result.errors.push(new ConversionError(`Failed to analyze resource config: ${error instanceof Error ? error.message : String(error)}`, JSON.stringify(config), 'unknown'));
+        }
+        return result;
+    }
+    /**
+     * Recursively analyze a configuration object for KubernetesRef objects
+     */
+    analyzeConfigObject(obj, fieldPath, context, result) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        // Check if this value contains KubernetesRef objects
+        if (!containsKubernetesRefs(obj)) {
+            // No KubernetesRef objects - return as-is for performance
+            return obj;
+        }
+        // Handle direct KubernetesRef objects
+        if (isKubernetesRef(obj)) {
+            return this.convertKubernetesRefInConfig(obj, fieldPath, context, result);
+        }
+        // Handle arrays
+        if (Array.isArray(obj)) {
+            return obj.map((item, index) => this.analyzeConfigObject(item, `${fieldPath}[${index}]`, context, result));
+        }
+        // Handle objects
+        if (typeof obj === 'object') {
+            const processedObj = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const currentFieldPath = fieldPath ? `${fieldPath}.${key}` : key;
+                processedObj[key] = this.analyzeConfigObject(value, currentFieldPath, context, result);
+            }
+            return processedObj;
+        }
+        // Handle primitive values that might be expressions
+        if (typeof obj === 'string' && this.looksLikeExpression(obj)) {
+            return this.analyzeStringExpression(obj, fieldPath, context, result);
+        }
+        return obj;
+    }
+    /**
+     * Convert a KubernetesRef object in a resource configuration
+     */
+    convertKubernetesRefInConfig(ref, fieldPath, context, result) {
+        try {
+            // Track this dependency
+            result.dependencies.push(ref);
+            result.convertedFields.push(fieldPath);
+            // Create analysis context for this KubernetesRef
+            const analysisContext = {
+                type: 'resource',
+                availableReferences: context.availableResources || {},
+                factoryType: context.factoryType,
+                sourceMap: new SourceMapBuilder(),
+                dependencies: [],
+                ...(context.schemaProxy && { schemaProxy: context.schemaProxy })
+            };
+            // Convert the KubernetesRef to CEL
+            const celExpression = this.analyzer.convertKubernetesRefToCel(ref, analysisContext);
+            // Add any additional dependencies found during conversion
+            result.dependencies.push(...(analysisContext.dependencies || []));
+            return celExpression;
+        }
+        catch (error) {
+            const conversionError = new ConversionError(`Failed to convert KubernetesRef at ${fieldPath}: ${error instanceof Error ? error.message : String(error)}`, `${ref.resourceId}.${ref.fieldPath}`, 'member-access');
+            result.errors.push(conversionError);
+            // Return the original ref on error
+            return ref;
+        }
+    }
+    /**
+     * Analyze string expressions that might contain KubernetesRef objects
+     */
+    analyzeStringExpression(expression, fieldPath, context, result) {
+        try {
+            // Create analysis context
+            const analysisContext = {
+                type: 'resource',
+                availableReferences: context.availableResources || {},
+                factoryType: context.factoryType,
+                sourceMap: new SourceMapBuilder(),
+                dependencies: [],
+                sourceText: expression,
+                ...(context.schemaProxy && { schemaProxy: context.schemaProxy })
+            };
+            // Analyze the expression
+            const conversionResult = this.analyzer.analyzeExpression(expression, analysisContext);
+            if (conversionResult.valid && conversionResult.requiresConversion) {
+                // Track dependencies and converted fields
+                result.dependencies.push(...conversionResult.dependencies);
+                result.convertedFields.push(fieldPath);
+                result.errors.push(...conversionResult.errors);
+                return conversionResult.celExpression;
+            }
+            // No conversion needed or failed - return original
+            result.errors.push(...conversionResult.errors);
+            return expression;
+        }
+        catch (error) {
+            const conversionError = new ConversionError(`Failed to analyze expression at ${fieldPath}: ${error instanceof Error ? error.message : String(error)}`, expression, 'javascript');
+            result.errors.push(conversionError);
+            return expression;
+        }
+    }
+    /**
+     * Check if a string looks like a JavaScript expression
+     */
+    looksLikeExpression(str) {
+        // Look for common expression patterns
+        return (str.includes('${') || // Template literals
+            str.includes('?.') || // Optional chaining
+            str.includes('||') || // Logical OR
+            str.includes('&&') || // Logical AND
+            str.includes('??') || // Nullish coalescing
+            /\w+\.\w+/.test(str) // Property access
+        );
+    }
+    /**
+     * Validate resource types for KubernetesRef objects
+     * This implements requirement 4.5: resource type validation
+     */
+    validateResourceTypes(dependencies, context) {
+        const validationContext = {
+            strictTypeChecking: context.validateResourceTypes || false,
+            ...(context.availableResources && { availableResources: context.availableResources }),
+            ...(context.schemaProxy && { schemaProxy: context.schemaProxy })
+        };
+        return dependencies.map(dep => this.typeValidator.validateKubernetesRef(dep, validationContext));
+    }
+    /**
+     * Get dependency information for a resource
+     */
+    getDependencyInfo(resourceId) {
+        return this.dependencyTracker.getDependencies(resourceId);
+    }
+    /**
+     * Get the full dependency graph
+     */
+    getDependencyGraph() {
+        return this.dependencyTracker.getDependencyGraph();
+    }
+    /**
+     * Get resources that depend on a specific resource
+     */
+    getDependents(resourceId) {
+        return this.dependencyTracker.getDependents(resourceId);
+    }
+    /**
+     * Check if there are circular dependencies
+     */
+    hasCircularDependencies() {
+        return this.dependencyTracker.hasCircularDependencies();
+    }
+    /**
+     * Get the recommended deployment order
+     */
+    getDeploymentOrder() {
+        return this.dependencyTracker.getDeploymentOrder();
+    }
+    /**
+     * Perform advanced circular dependency analysis
+     * This provides detailed analysis and recommendations for resolving circular dependencies
+     */
+    analyzeCircularDependencies() {
+        return this.dependencyTracker.detectCircularDependencyChains();
+    }
+    /**
+     * Get the resource type validator
+     */
+    getTypeValidator() {
+        return this.typeValidator;
+    }
+    /**
+     * Register a custom schema validator
+     */
+    registerSchemaValidator(schemaType, validator) {
+        this.typeValidator.registerSchemaValidator(schemaType, validator);
+    }
+    /**
+     * Register a custom resource type
+     */
+    registerResourceType(name, typeInfo) {
+        this.typeValidator.registerResourceType(name, typeInfo);
+    }
+    /**
+     * Validate a single KubernetesRef for type correctness
+     */
+    validateKubernetesRef(ref, context) {
+        return this.typeValidator.validateKubernetesRef(ref, context);
+    }
+}
+/**
+ * Convenience function for analyzing resource configurations
+ * This is the main entry point for resource builder integration
+ */
+export function analyzeResourceConfig(resourceId, config, context) {
+    const analyzer = new ResourceAnalyzer();
+    const fullContext = {
+        ...context,
+        resourceId,
+        resourceConfig: config
+    };
+    return analyzer.analyzeResourceConfig(resourceId, config, fullContext);
+}
+/**
+ * Analyze resource configurations for factory function integration with KubernetesRef detection
+ * This function integrates with existing factory functions to detect and convert
+ * JavaScript expressions that contain KubernetesRef objects from the magic proxy system
+ */
+export function analyzeFactoryResourceConfig(resourceId, config, availableResources, schemaProxy, factoryType = 'kro') {
+    const context = {
+        type: 'resource',
+        resourceId,
+        resourceConfig: config,
+        availableReferences: availableResources,
+        availableResources,
+        factoryType,
+        validateResourceTypes: true,
+        sourceMap: new SourceMapBuilder(),
+        ...(schemaProxy && { schemaProxy })
+    };
+    return analyzeResourceConfig(resourceId, config, context);
+}
+/**
+ * Automatic dependency tracker for KubernetesRef objects in expressions
+ * This implements requirement 4.2: automatic dependency tracking
+ */
+export class DependencyTracker {
+    dependencyGraph;
+    constructor() {
+        this.dependencyGraph = {
+            dependencies: new Map(),
+            dependents: new Map(),
+            circularChains: [],
+            deploymentOrder: []
+        };
+    }
+    /**
+     * Track dependencies for a resource configuration
+     */
+    trackDependencies(resourceId, dependencies, fieldPaths, options = {}) {
+        const dependencyInfos = [];
+        for (let i = 0; i < dependencies.length; i++) {
+            const dep = dependencies[i];
+            if (!dep)
+                continue;
+            const fieldPath = fieldPaths[i] || `unknown[${i}]`;
+            const dependencyInfo = this.createDependencyInfo(dep, fieldPath, options);
+            dependencyInfos.push(dependencyInfo);
+            // Add to dependency graph
+            this.addToDependencyGraph(resourceId, dependencyInfo);
+        }
+        // Update dependency graph computations
+        if (options.detectCircularDependencies) {
+            this.detectCircularDependencies();
+        }
+        if (options.computeDeploymentOrder) {
+            this.computeDeploymentOrder();
+        }
+        return dependencyInfos;
+    }
+    /**
+     * Create dependency information for a KubernetesRef
+     */
+    createDependencyInfo(ref, fieldPath, options) {
+        const dependencyType = this.determineDependencyType(ref);
+        // Skip tracking based on options
+        if (dependencyType === 'schema' && options.trackSchemaDependencies === false) {
+            return this.createSkippedDependencyInfo(ref, fieldPath, dependencyType);
+        }
+        if (dependencyType === 'resource' && options.trackResourceDependencies === false) {
+            return this.createSkippedDependencyInfo(ref, fieldPath, dependencyType);
+        }
+        if (dependencyType === 'external' && options.trackExternalDependencies === false) {
+            return this.createSkippedDependencyInfo(ref, fieldPath, dependencyType);
+        }
+        return {
+            reference: ref,
+            fieldPath,
+            dependencyType,
+            required: this.isDependencyRequired(ref, fieldPath),
+            expectedType: ref._type ? String(ref._type) : 'unknown',
+            metadata: {
+                affectsReadiness: this.affectsReadiness(ref, fieldPath),
+                conditional: this.isConditional(fieldPath),
+                expressionContext: this.getExpressionContext(fieldPath)
+            }
+        };
+    }
+    /**
+     * Create a skipped dependency info (for disabled tracking)
+     */
+    createSkippedDependencyInfo(ref, fieldPath, dependencyType) {
+        return {
+            reference: ref,
+            fieldPath,
+            dependencyType,
+            required: false,
+            expectedType: 'skipped',
+            metadata: {
+                affectsReadiness: false,
+                conditional: false,
+                expressionContext: 'skipped'
+            }
+        };
+    }
+    /**
+     * Determine the type of dependency
+     */
+    determineDependencyType(ref) {
+        if (ref.resourceId === '__schema__') {
+            return 'schema';
+        }
+        // Check if it's a known resource type
+        if (ref.resourceId.match(/^[a-z][a-z0-9-]*$/)) {
+            return 'resource';
+        }
+        return 'external';
+    }
+    /**
+     * Determine if a dependency is required
+     */
+    isDependencyRequired(ref, fieldPath) {
+        // Schema dependencies are generally required
+        if (ref.resourceId === '__schema__') {
+            return true;
+        }
+        // Dependencies in required fields are required
+        if (this.isRequiredField(fieldPath)) {
+            return true;
+        }
+        // Dependencies in conditional expressions may not be required
+        if (this.isConditional(fieldPath)) {
+            return false;
+        }
+        // Default to required for safety
+        return true;
+    }
+    /**
+     * Check if a field path represents a required field
+     */
+    isRequiredField(fieldPath) {
+        // Common required fields
+        const requiredFields = ['name', 'image', 'namespace'];
+        return requiredFields.some(field => fieldPath.includes(field));
+    }
+    /**
+     * Check if a dependency affects resource readiness
+     */
+    affectsReadiness(ref, fieldPath) {
+        // Status field dependencies typically affect readiness
+        if (ref.fieldPath.startsWith('status.')) {
+            return true;
+        }
+        // Dependencies in readiness-related fields
+        const readinessFields = ['ready', 'available', 'replicas', 'conditions'];
+        return readinessFields.some(field => fieldPath.includes(field) || ref.fieldPath.includes(field));
+    }
+    /**
+     * Check if a field path is in a conditional context
+     */
+    isConditional(fieldPath) {
+        // Look for conditional patterns in field path
+        return fieldPath.includes('?') ||
+            fieldPath.includes('||') ||
+            fieldPath.includes('&&') ||
+            fieldPath.includes('??');
+    }
+    /**
+     * Get expression context for a field path
+     */
+    getExpressionContext(fieldPath) {
+        // Extract the top-level field context
+        const parts = fieldPath.split('.');
+        if (parts.length > 0 && parts[0]) {
+            return parts[0];
+        }
+        return 'unknown';
+    }
+    /**
+     * Add dependency info to the dependency graph
+     */
+    addToDependencyGraph(resourceId, dependencyInfo) {
+        // Add to dependencies map
+        if (!this.dependencyGraph.dependencies.has(resourceId)) {
+            this.dependencyGraph.dependencies.set(resourceId, []);
+        }
+        this.dependencyGraph.dependencies.get(resourceId)?.push(dependencyInfo);
+        // Add to dependents map (reverse mapping)
+        const dependentResourceId = dependencyInfo.reference.resourceId;
+        if (dependentResourceId !== '__schema__') {
+            if (!this.dependencyGraph.dependents.has(dependentResourceId)) {
+                this.dependencyGraph.dependents.set(dependentResourceId, []);
+            }
+            const dependents = this.dependencyGraph.dependents.get(dependentResourceId);
+            if (!dependents.includes(resourceId)) {
+                dependents.push(resourceId);
+            }
+        }
+    }
+    /**
+     * Detect circular dependencies in the dependency graph
+     */
+    detectCircularDependencies() {
+        this.dependencyGraph.circularChains = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        // Check each resource for cycles
+        for (const resourceId of this.dependencyGraph.dependencies.keys()) {
+            if (!visited.has(resourceId)) {
+                this.detectCyclesFromResource(resourceId, [], visited, recursionStack);
+            }
+        }
+    }
+    /**
+     * Detect cycles starting from a specific resource
+     */
+    detectCyclesFromResource(resourceId, path, visited, recursionStack) {
+        if (recursionStack.has(resourceId)) {
+            // Found a cycle
+            const cycleStart = path.indexOf(resourceId);
+            if (cycleStart >= 0) {
+                const cycle = path.slice(cycleStart).concat([resourceId]);
+                this.dependencyGraph.circularChains.push(cycle);
+            }
+            return;
+        }
+        if (visited.has(resourceId)) {
+            return;
+        }
+        visited.add(resourceId);
+        recursionStack.add(resourceId);
+        // Follow dependencies
+        const dependencies = this.dependencyGraph.dependencies.get(resourceId) || [];
+        for (const dep of dependencies) {
+            if (dep.reference.resourceId !== '__schema__') {
+                this.detectCyclesFromResource(dep.reference.resourceId, [...path, resourceId], visited, recursionStack);
+            }
+        }
+        recursionStack.delete(resourceId);
+    }
+    /**
+     * Compute deployment order using topological sort
+     */
+    computeDeploymentOrder() {
+        const inDegree = new Map();
+        const adjList = new Map();
+        // Initialize in-degree and adjacency list
+        for (const [resourceId, dependencies] of this.dependencyGraph.dependencies) {
+            if (!inDegree.has(resourceId)) {
+                inDegree.set(resourceId, 0);
+            }
+            if (!adjList.has(resourceId)) {
+                adjList.set(resourceId, []);
+            }
+            for (const dep of dependencies) {
+                if (dep.reference.resourceId !== '__schema__') {
+                    const depResourceId = dep.reference.resourceId;
+                    if (!inDegree.has(depResourceId)) {
+                        inDegree.set(depResourceId, 0);
+                    }
+                    if (!adjList.has(depResourceId)) {
+                        adjList.set(depResourceId, []);
+                    }
+                    // Add edge from dependency to dependent
+                    adjList.get(depResourceId)?.push(resourceId);
+                    inDegree.set(resourceId, inDegree.get(resourceId) + 1);
+                }
+            }
+        }
+        // Kahn's algorithm for topological sort
+        const queue = [];
+        const result = [];
+        // Find all resources with no dependencies
+        for (const [resourceId, degree] of inDegree) {
+            if (degree === 0) {
+                queue.push(resourceId);
+            }
+        }
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            // Process all dependents
+            const dependents = adjList.get(current) || [];
+            for (const dependent of dependents) {
+                const newDegree = inDegree.get(dependent) - 1;
+                inDegree.set(dependent, newDegree);
+                if (newDegree === 0) {
+                    queue.push(dependent);
+                }
+            }
+        }
+        this.dependencyGraph.deploymentOrder = result;
+    }
+    /**
+     * Get the current dependency graph
+     */
+    getDependencyGraph() {
+        return { ...this.dependencyGraph };
+    }
+    /**
+     * Get dependencies for a specific resource
+     */
+    getDependencies(resourceId) {
+        return this.dependencyGraph.dependencies.get(resourceId) || [];
+    }
+    /**
+     * Get resources that depend on a specific resource
+     */
+    getDependents(resourceId) {
+        return this.dependencyGraph.dependents.get(resourceId) || [];
+    }
+    /**
+     * Check if there are circular dependencies
+     */
+    hasCircularDependencies() {
+        return this.dependencyGraph.circularChains.length > 0;
+    }
+    /**
+     * Get the deployment order
+     */
+    getDeploymentOrder() {
+        return [...this.dependencyGraph.deploymentOrder];
+    }
+    /**
+     * Reset the dependency graph
+     */
+    reset() {
+        this.dependencyGraph = {
+            dependencies: new Map(),
+            dependents: new Map(),
+            circularChains: [],
+            deploymentOrder: []
+        };
+    }
+    /**
+     * Advanced circular dependency detection with detailed chain analysis
+     * This provides more sophisticated analysis of KubernetesRef chains
+     */
+    detectCircularDependencyChains() {
+        const analysis = {
+            hasCircularDependencies: false,
+            circularChains: [],
+            chainAnalysis: [],
+            recommendations: []
+        };
+        // Use Tarjan's strongly connected components algorithm for better cycle detection
+        const tarjanResult = this.findStronglyConnectedComponents();
+        for (const component of tarjanResult.components) {
+            if (component.length > 1) {
+                // This is a circular dependency
+                analysis.hasCircularDependencies = true;
+                analysis.circularChains.push(component);
+                // Analyze the chain
+                const chainAnalysis = this.analyzeCircularChain(component);
+                analysis.chainAnalysis.push(chainAnalysis);
+                // Generate recommendations
+                const recommendations = this.generateCircularDependencyRecommendations(chainAnalysis);
+                analysis.recommendations.push(...recommendations);
+            }
+        }
+        return analysis;
+    }
+    /**
+     * Find strongly connected components using Tarjan's algorithm
+     */
+    findStronglyConnectedComponents() {
+        const index = new Map();
+        const lowLink = new Map();
+        const onStack = new Set();
+        const stack = [];
+        const components = [];
+        let currentIndex = 0;
+        const strongConnect = (resourceId) => {
+            index.set(resourceId, currentIndex);
+            lowLink.set(resourceId, currentIndex);
+            currentIndex++;
+            stack.push(resourceId);
+            onStack.add(resourceId);
+            // Get dependencies for this resource
+            const dependencies = this.dependencyGraph.dependencies.get(resourceId) || [];
+            for (const dep of dependencies) {
+                const depResourceId = dep.reference.resourceId;
+                if (depResourceId === '__schema__')
+                    continue; // Skip schema references
+                if (!index.has(depResourceId)) {
+                    strongConnect(depResourceId);
+                    lowLink.set(resourceId, Math.min(lowLink.get(resourceId), lowLink.get(depResourceId)));
+                }
+                else if (onStack.has(depResourceId)) {
+                    lowLink.set(resourceId, Math.min(lowLink.get(resourceId), index.get(depResourceId)));
+                }
+            }
+            // If resourceId is a root node, pop the stack and create a component
+            if (lowLink.get(resourceId) === index.get(resourceId)) {
+                const component = [];
+                let w;
+                do {
+                    w = stack.pop();
+                    onStack.delete(w);
+                    component.push(w);
+                } while (w !== resourceId);
+                components.push(component);
+            }
+        };
+        // Run algorithm on all unvisited nodes
+        for (const resourceId of this.dependencyGraph.dependencies.keys()) {
+            if (!index.has(resourceId)) {
+                strongConnect(resourceId);
+            }
+        }
+        return { components };
+    }
+    /**
+     * Analyze a circular dependency chain
+     */
+    analyzeCircularChain(chain) {
+        const analysis = {
+            chain,
+            chainLength: chain.length,
+            severity: this.calculateChainSeverity(chain),
+            breakPoints: this.findPotentialBreakPoints(chain),
+            affectedFields: this.getAffectedFields(chain),
+            riskLevel: 'medium'
+        };
+        // Determine risk level
+        if (analysis.severity > 0.8 || analysis.chainLength > 5) {
+            analysis.riskLevel = 'high';
+        }
+        else if (analysis.severity < 0.3 && analysis.chainLength <= 2) {
+            analysis.riskLevel = 'low';
+        }
+        return analysis;
+    }
+    /**
+     * Calculate the severity of a circular dependency chain
+     */
+    calculateChainSeverity(chain) {
+        let severity = 0;
+        let totalDependencies = 0;
+        for (const resourceId of chain) {
+            const dependencies = this.dependencyGraph.dependencies.get(resourceId) || [];
+            totalDependencies += dependencies.length;
+            // Increase severity for required dependencies
+            const requiredDeps = dependencies.filter(dep => dep.required);
+            severity += requiredDeps.length * 0.3;
+            // Increase severity for readiness-affecting dependencies
+            const readinessDeps = dependencies.filter(dep => dep.metadata?.affectsReadiness);
+            severity += readinessDeps.length * 0.2;
+        }
+        // Normalize by chain length and total dependencies
+        return Math.min(severity / (chain.length * Math.max(totalDependencies, 1)), 1);
+    }
+    /**
+     * Find potential break points in a circular chain
+     */
+    findPotentialBreakPoints(chain) {
+        const breakPoints = [];
+        for (const resourceId of chain) {
+            const dependencies = this.dependencyGraph.dependencies.get(resourceId) || [];
+            // Look for optional dependencies that could be break points
+            const optionalDeps = dependencies.filter(dep => !dep.required);
+            if (optionalDeps.length > 0) {
+                breakPoints.push(resourceId);
+            }
+            // Look for conditional dependencies
+            const conditionalDeps = dependencies.filter(dep => dep.metadata?.conditional);
+            if (conditionalDeps.length > 0) {
+                breakPoints.push(resourceId);
+            }
+        }
+        return [...new Set(breakPoints)]; // Remove duplicates
+    }
+    /**
+     * Get affected fields for a circular chain
+     */
+    getAffectedFields(chain) {
+        const affectedFields = [];
+        for (const resourceId of chain) {
+            const dependencies = this.dependencyGraph.dependencies.get(resourceId) || [];
+            for (const dep of dependencies) {
+                if (chain.includes(dep.reference.resourceId)) {
+                    affectedFields.push(`${resourceId}.${dep.fieldPath}`);
+                }
+            }
+        }
+        return affectedFields;
+    }
+    /**
+     * Generate recommendations for resolving circular dependencies
+     */
+    generateCircularDependencyRecommendations(chainAnalysis) {
+        const recommendations = [];
+        // Recommend breaking at optional dependencies
+        if (chainAnalysis.breakPoints.length > 0) {
+            recommendations.push({
+                type: 'break-optional-dependency',
+                description: `Consider making dependencies optional at: ${chainAnalysis.breakPoints.join(', ')}`,
+                severity: 'medium',
+                affectedResources: chainAnalysis.breakPoints,
+                implementation: 'Use conditional expressions or default values for these dependencies'
+            });
+        }
+        // Recommend refactoring for high-severity chains
+        if (chainAnalysis.severity > 0.7) {
+            recommendations.push({
+                type: 'refactor-architecture',
+                description: 'Consider refactoring the resource architecture to eliminate circular dependencies',
+                severity: 'high',
+                affectedResources: chainAnalysis.chain,
+                implementation: 'Extract shared dependencies into separate resources or use event-driven patterns'
+            });
+        }
+        // Recommend using external configuration for long chains
+        if (chainAnalysis.chainLength > 4) {
+            recommendations.push({
+                type: 'external-configuration',
+                description: 'Consider using external configuration (ConfigMaps, Secrets) to break the dependency chain',
+                severity: 'medium',
+                affectedResources: chainAnalysis.chain,
+                implementation: 'Move configuration values to ConfigMaps and reference them instead of cross-resource dependencies'
+            });
+        }
+        return recommendations;
+    }
+}
+/**
+ * Comprehensive resource type validator for KubernetesRef objects
+ * This implements requirement 4.5: resource type validation
+ */
+export class ResourceTypeValidator {
+    knownResourceTypes;
+    schemaValidators;
+    constructor() {
+        this.knownResourceTypes = new Map();
+        this.schemaValidators = new Map();
+        this.initializeKnownTypes();
+    }
+    /**
+     * Validate a KubernetesRef for type correctness
+     */
+    validateKubernetesRef(ref, context) {
+        const result = {
+            fieldPath: `${ref.resourceId}.${ref.fieldPath}`,
+            reference: ref,
+            valid: true,
+            expectedType: ref._type ? String(ref._type) : 'unknown'
+        };
+        try {
+            if (ref.resourceId === '__schema__') {
+                return this.validateSchemaRef(ref, context, result);
+            }
+            else {
+                return this.validateResourceRef(ref, context, result);
+            }
+        }
+        catch (error) {
+            result.valid = false;
+            result.error = error instanceof Error ? error.message : String(error);
+            return result;
+        }
+    }
+    /**
+     * Validate a schema reference
+     */
+    validateSchemaRef(ref, context, result) {
+        if (!context.schemaProxy) {
+            result.valid = false;
+            result.error = 'Schema proxy not available for validation';
+            return result;
+        }
+        // Validate field path structure
+        const pathValidation = this.validateSchemaFieldPath(ref.fieldPath);
+        if (!pathValidation.valid) {
+            result.valid = false;
+            result.error = pathValidation.error || 'Validation failed';
+            return result;
+        }
+        // Validate against schema if available
+        const schemaValidator = this.schemaValidators.get(context.schemaType || 'default');
+        if (schemaValidator) {
+            const schemaValidation = schemaValidator.validateField(ref.fieldPath, ref._type);
+            if (!schemaValidation.valid) {
+                result.valid = false;
+                result.error = schemaValidation.error || 'Schema validation failed';
+                result.actualType = schemaValidation.actualType || 'unknown';
+            }
+        }
+        return result;
+    }
+    /**
+     * Validate a resource reference
+     */
+    validateResourceRef(ref, context, result) {
+        // Check if resource exists
+        const resource = context.availableResources?.[ref.resourceId];
+        if (!resource) {
+            result.valid = false;
+            result.error = `Resource '${ref.resourceId}' not found`;
+            return result;
+        }
+        // Validate field path structure
+        const pathValidation = this.validateResourceFieldPath(ref.fieldPath, resource);
+        if (!pathValidation.valid) {
+            result.valid = false;
+            result.error = pathValidation.error || 'Path validation failed';
+            result.actualType = pathValidation.actualType || 'unknown';
+            return result;
+        }
+        // Validate type compatibility
+        const typeValidation = this.validateTypeCompatibility(ref, resource);
+        if (!typeValidation.valid) {
+            result.valid = false;
+            result.error = typeValidation.error || 'Type validation failed';
+            result.actualType = typeValidation.actualType || 'unknown';
+        }
+        return result;
+    }
+    /**
+     * Validate schema field path structure
+     */
+    validateSchemaFieldPath(fieldPath) {
+        const parts = fieldPath.split('.');
+        if (parts.length < 2) {
+            return {
+                valid: false,
+                error: 'Schema field path must have at least 2 parts (e.g., spec.name)'
+            };
+        }
+        const rootField = parts[0];
+        if (rootField !== 'spec' && rootField !== 'status') {
+            return {
+                valid: false,
+                error: `Schema field path must start with 'spec' or 'status', got '${rootField}'`
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Validate resource field path structure
+     */
+    validateResourceFieldPath(fieldPath, resource) {
+        const parts = fieldPath.split('.');
+        if (parts.length === 0) {
+            return {
+                valid: false,
+                error: 'Field path cannot be empty'
+            };
+        }
+        const rootField = parts[0];
+        const validRootFields = ['metadata', 'spec', 'status'];
+        if (!rootField || !validRootFields.includes(rootField)) {
+            return {
+                valid: false,
+                error: `Invalid root field '${rootField || 'undefined'}'. Must be one of: ${validRootFields.join(', ')}`
+            };
+        }
+        // Validate specific field patterns
+        const patternValidation = this.validateFieldPattern(fieldPath);
+        if (!patternValidation.valid) {
+            return patternValidation;
+        }
+        // Try to infer actual type from resource
+        const actualType = this.inferFieldType(fieldPath, resource);
+        return {
+            valid: true,
+            actualType: actualType || 'unknown'
+        };
+    }
+    /**
+     * Validate field patterns against known Kubernetes patterns
+     */
+    validateFieldPattern(fieldPath) {
+        // Known valid patterns
+        const validPatterns = [
+            // Metadata fields
+            { pattern: /^metadata\.(name|namespace|uid|resourceVersion|generation)$/, type: 'string' },
+            { pattern: /^metadata\.labels\..+$/, type: 'string' },
+            { pattern: /^metadata\.annotations\..+$/, type: 'string' },
+            // Common spec fields
+            { pattern: /^spec\.replicas$/, type: 'number' },
+            { pattern: /^spec\.selector\.matchLabels\..+$/, type: 'string' },
+            // Common status fields
+            { pattern: /^status\.ready$/, type: 'boolean' },
+            { pattern: /^status\.(replicas|readyReplicas|availableReplicas|unavailableReplicas)$/, type: 'number' },
+            { pattern: /^status\.conditions\[\d+\]\.(type|status|reason|message)$/, type: 'string' },
+            { pattern: /^status\.conditions\[\d+\]\.lastTransitionTime$/, type: 'string' },
+            { pattern: /^status\.loadBalancer\.ingress\[\d+\]\.(ip|hostname)$/, type: 'string' },
+            { pattern: /^status\.(podIP|hostIP)$/, type: 'string' },
+            { pattern: /^status\.phase$/, type: 'string' },
+            // Generic patterns
+            { pattern: /^spec\./, type: 'unknown' },
+            { pattern: /^status\./, type: 'unknown' }
+        ];
+        const matchingPattern = validPatterns.find(p => p.pattern.test(fieldPath));
+        if (!matchingPattern) {
+            return {
+                valid: false,
+                error: `Field path '${fieldPath}' does not match any known Kubernetes field patterns`
+            };
+        }
+        return {
+            valid: true,
+            actualType: matchingPattern.type
+        };
+    }
+    /**
+     * Validate type compatibility between expected and actual types
+     */
+    validateTypeCompatibility(ref, resource) {
+        if (!ref._type) {
+            // No expected type specified, assume compatible
+            return { valid: true };
+        }
+        const expectedType = String(ref._type);
+        const actualType = this.inferFieldType(ref.fieldPath, resource);
+        if (!actualType || actualType === 'unknown') {
+            // Cannot determine actual type, assume compatible
+            return { valid: true };
+        }
+        // Check type compatibility
+        const compatible = this.areTypesCompatible(expectedType, actualType);
+        if (!compatible) {
+            return {
+                valid: false,
+                error: `Type mismatch: expected '${expectedType}' but field has type '${actualType}'`,
+                actualType
+            };
+        }
+        return { valid: true, actualType };
+    }
+    /**
+     * Check if two types are compatible
+     */
+    areTypesCompatible(expectedType, actualType) {
+        // Exact match
+        if (expectedType === actualType) {
+            return true;
+        }
+        // Compatible type mappings
+        const compatibleTypes = {
+            'string': ['string', 'unknown'],
+            'number': ['number', 'integer', 'float', 'unknown'],
+            'boolean': ['boolean', 'unknown'],
+            'object': ['object', 'unknown'],
+            'array': ['array', 'unknown'],
+            'unknown': ['string', 'number', 'boolean', 'object', 'array', 'unknown']
+        };
+        const compatibleWithExpected = compatibleTypes[expectedType] || [];
+        return compatibleWithExpected.includes(actualType);
+    }
+    /**
+     * Infer the type of a field from a resource
+     */
+    inferFieldType(fieldPath, _resource) {
+        // Try to infer type from field path patterns
+        if (fieldPath.includes('replicas') || fieldPath.includes('generation') || fieldPath.includes('port')) {
+            return 'number';
+        }
+        if (fieldPath.includes('ready') || fieldPath.includes('enabled')) {
+            return 'boolean';
+        }
+        if (fieldPath.includes('name') || fieldPath.includes('namespace') || fieldPath.includes('ip') || fieldPath.includes('phase')) {
+            return 'string';
+        }
+        if (fieldPath.includes('labels') || fieldPath.includes('annotations') || fieldPath.includes('selector')) {
+            return 'object';
+        }
+        if (fieldPath.includes('conditions') || fieldPath.includes('ingress')) {
+            return 'array';
+        }
+        return 'unknown';
+    }
+    /**
+     * Initialize known resource types
+     */
+    initializeKnownTypes() {
+        // Common Kubernetes resource types
+        this.knownResourceTypes.set('Deployment', {
+            apiVersion: 'apps/v1',
+            kind: 'Deployment',
+            commonFields: {
+                'metadata.name': 'string',
+                'metadata.namespace': 'string',
+                'spec.replicas': 'number',
+                'status.readyReplicas': 'number',
+                'status.availableReplicas': 'number'
+            }
+        });
+        this.knownResourceTypes.set('Service', {
+            apiVersion: 'v1',
+            kind: 'Service',
+            commonFields: {
+                'metadata.name': 'string',
+                'metadata.namespace': 'string',
+                'spec.type': 'string',
+                'spec.ports': 'array',
+                'status.loadBalancer.ingress': 'array'
+            }
+        });
+        this.knownResourceTypes.set('Pod', {
+            apiVersion: 'v1',
+            kind: 'Pod',
+            commonFields: {
+                'metadata.name': 'string',
+                'metadata.namespace': 'string',
+                'status.phase': 'string',
+                'status.podIP': 'string',
+                'status.hostIP': 'string'
+            }
+        });
+    }
+    /**
+     * Register a custom schema validator
+     */
+    registerSchemaValidator(schemaType, validator) {
+        this.schemaValidators.set(schemaType, validator);
+    }
+    /**
+     * Register a custom resource type
+     */
+    registerResourceType(name, typeInfo) {
+        this.knownResourceTypes.set(name, typeInfo);
+    }
+}
+//# sourceMappingURL=resource-analyzer.js.map