typekro 0.4.0 → 0.5.0

package/dist/core/expressions/composition-integration.js

@@ -1,944 +0,0 @@
-/**
- * Composition Integration for JavaScript to CEL Expression Conversion
- *
- * This module provides integration between the kubernetesComposition API and the
- * JavaScript to CEL expression conversion system. It handles KubernetesRef detection
- * and conversion within imperative composition patterns.
- */
-import { getCurrentCompositionContext } from '../../factories/shared.js';
-import { isKubernetesRef } from '../../utils/type-guards.js';
-import { MagicAssignableAnalyzer } from './magic-assignable-analyzer.js';
-import { CelConversionEngine } from './cel-conversion-engine.js';
-/**
- * Composition-aware expression analyzer that integrates with kubernetesComposition
- */
-export class CompositionExpressionAnalyzer {
-    magicAssignableAnalyzer;
-    celEngine;
-    patternConfigs;
-    contextTracker;
-    scopeManager;
-    constructor() {
-        this.magicAssignableAnalyzer = new MagicAssignableAnalyzer();
-        this.celEngine = new CelConversionEngine();
-        this.contextTracker = new CompositionContextTracker();
-        this.scopeManager = new MagicProxyScopeManager();
-        // Initialize pattern-specific configurations
-        this.patternConfigs = new Map([
-            [
-                'imperative',
-                {
-                    pattern: 'imperative',
-                    allowSideEffects: true,
-                    trackResourceCreation: true,
-                    validateScope: true,
-                    convertTocel: true,
-                },
-            ],
-            [
-                'declarative',
-                {
-                    pattern: 'declarative',
-                    allowSideEffects: false,
-                    trackResourceCreation: false,
-                    validateScope: false,
-                    convertTocel: true,
-                },
-            ],
-        ]);
-    }
-    /**
-     * Detect the composition pattern being used
-     */
-    detectCompositionPattern(compositionFn, context) {
-        // If there's an active composition context, it's imperative
-        if (context || getCurrentCompositionContext()) {
-            return 'imperative';
-        }
-        // Analyze function signature and behavior
-        const fnString = compositionFn.toString();
-        // Look for imperative patterns
-        const imperativeIndicators = [
-            /\.add\w+\(/, // .addResource, .addService, etc.
-            /register\w+\(/, // registerResource, etc.
-            /create\w+\(/, // createResource, etc.
-            /simple\w+\(/, // simpleDeployment, simpleService, etc.
-        ];
-        const hasImperativeIndicators = imperativeIndicators.some((pattern) => pattern.test(fnString));
-        return hasImperativeIndicators ? 'imperative' : 'declarative';
-    }
-    /**
-     * Analyze composition function with pattern awareness
-     */
-    analyzeCompositionFunctionWithPattern(compositionFn, schemaProxy, pattern, context) {
-        // Detect pattern if not provided
-        const detectedPattern = pattern || this.detectCompositionPattern(compositionFn, context);
-        const config = this.patternConfigs.get(detectedPattern);
-        // Track side effects if this is an imperative pattern
-        let sideEffectsDetected = false;
-        let resourceCreationTracked = false;
-        let scopeValidationPerformed = false;
-        if (config.trackResourceCreation && context) {
-            const resourcesBefore = new Set(Object.keys(context.resources));
-            // Execute the base analysis
-            const baseResult = this.analyzeCompositionFunction(compositionFn, schemaProxy, context);
-            // Check for side effects
-            const resourcesAfter = Object.keys(context.resources);
-            sideEffectsDetected = resourcesAfter.some((id) => !resourcesBefore.has(id));
-            resourceCreationTracked = true;
-            // Perform scope validation if enabled
-            if (config.validateScope) {
-                // This would be handled by the scope manager
-                scopeValidationPerformed = true;
-            }
-            return {
-                ...baseResult,
-                pattern: detectedPattern,
-                patternSpecificMetadata: {
-                    sideEffectsDetected,
-                    resourceCreationTracked,
-                    scopeValidationPerformed,
-                },
-            };
-        }
-        else {
-            // Execute the base analysis without side effect tracking
-            const baseResult = this.analyzeCompositionFunction(compositionFn, schemaProxy, context);
-            return {
-                ...baseResult,
-                pattern: detectedPattern,
-                patternSpecificMetadata: {
-                    sideEffectsDetected,
-                    resourceCreationTracked,
-                    scopeValidationPerformed,
-                },
-            };
-        }
-    }
-    /**
-     * Process composition based on detected pattern
-     */
-    processCompositionByPattern(statusShape, pattern, factoryType = 'kro') {
-        const config = this.patternConfigs.get(pattern);
-        if (!config.convertTocel) {
-            // Pattern doesn't require CEL conversion
-            return statusShape;
-        }
-        // Use the standard processing logic
-        return this.processCompositionStatus(statusShape, factoryType);
-    }
-    /**
-     * Validate composition pattern compatibility
-     */
-    validatePatternCompatibility(pattern, factoryType, context) {
-        const warnings = [];
-        const recommendations = [];
-        let isCompatible = true;
-        const config = this.patternConfigs.get(pattern);
-        // Check imperative pattern with direct factory
-        if (pattern === 'imperative' && factoryType === 'direct') {
-            if (!context) {
-                warnings.push('Imperative pattern without composition context may not work correctly with direct factory');
-                recommendations.push('Ensure kubernetesComposition is used with proper context management');
-            }
-        }
-        // Check declarative pattern with side effects
-        if (pattern === 'declarative' && config.allowSideEffects && context) {
-            const resourceCount = Object.keys(context.resources).length;
-            if (resourceCount > 0) {
-                warnings.push('Declarative pattern detected but resources found in composition context');
-                recommendations.push('Consider using imperative pattern (kubernetesComposition) for side-effect based resource creation');
-            }
-        }
-        // Check CEL conversion compatibility
-        if (factoryType === 'kro' && !config.convertTocel) {
-            isCompatible = false;
-            warnings.push(`Pattern '${pattern}' is not compatible with Kro factory (CEL conversion required)`);
-            recommendations.push('Use direct factory or enable CEL conversion for this pattern');
-        }
-        return {
-            isCompatible,
-            warnings,
-            recommendations,
-        };
-    }
-    /**
-     * Get pattern-specific analysis recommendations
-     */
-    getPatternRecommendations(pattern, analysisResult) {
-        const recommendations = [];
-        if (pattern === 'imperative') {
-            if (analysisResult.kubernetesRefs.length === 0) {
-                recommendations.push('Consider using declarative pattern (toResourceGraph) for static compositions without KubernetesRef objects');
-            }
-            if (analysisResult.referencedResources.length > 10) {
-                recommendations.push('Large number of resource references detected - consider breaking into smaller compositions');
-            }
-        }
-        if (pattern === 'declarative') {
-            if (analysisResult.kubernetesRefs.length > 0) {
-                recommendations.push('KubernetesRef objects detected - imperative pattern (kubernetesComposition) might be more suitable');
-            }
-        }
-        return recommendations;
-    }
-    /**
-     * Analyze a composition function for KubernetesRef usage and expression conversion needs
-     */
-    analyzeCompositionFunction(compositionFn, schemaProxy, context) {
-        const _startTime = Date.now();
-        try {
-            // Execute the composition function to capture the returned status shape
-            const statusShape = compositionFn(schemaProxy.spec);
-            // Create analysis context
-            const analysisContext = {
-                type: 'status',
-                availableReferences: context?.resources || {},
-                schemaProxy,
-                factoryType: 'kro',
-            };
-            // Analyze the status shape for KubernetesRef objects
-            const analysisResult = this.magicAssignableAnalyzer.analyzeMagicAssignableShape(statusShape, analysisContext);
-            // Extract referenced resources from the composition context if available
-            const referencedResources = this.extractReferencedResources(context);
-            // Determine if CEL conversion is needed
-            const requiresCelConversion = analysisResult.dependencies.length > 0;
-            const conversionMetadata = {
-                expressionsAnalyzed: Object.keys(analysisResult.fieldResults).length,
-                kubernetesRefsDetected: analysisResult.dependencies.length,
-                celExpressionsGenerated: requiresCelConversion
-                    ? Object.keys(analysisResult.fieldResults).length
-                    : 0,
-            };
-            return {
-                statusShape,
-                kubernetesRefs: analysisResult.dependencies,
-                referencedResources,
-                requiresCelConversion,
-                conversionMetadata,
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to analyze composition function: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Analyze a composition function's resource creation patterns
-     */
-    analyzeResourceCreation(compositionFn, schemaProxy, context) {
-        const currentContext = context || getCurrentCompositionContext();
-        if (!currentContext) {
-            return {
-                resourcesCreated: [],
-                kubernetesRefsInResources: [],
-                requiresCelConversion: false,
-            };
-        }
-        // Track resources before execution
-        const resourcesBefore = new Set(Object.keys(currentContext.resources));
-        try {
-            // Execute the composition function to trigger resource creation
-            compositionFn(schemaProxy.spec);
-            // Find newly created resources
-            const resourcesAfter = Object.keys(currentContext.resources);
-            const resourcesCreated = resourcesAfter.filter((id) => !resourcesBefore.has(id));
-            // Analyze newly created resources for KubernetesRef objects
-            const kubernetesRefsInResources = [];
-            for (const resourceId of resourcesCreated) {
-                const resource = currentContext.resources[resourceId];
-                if (resource) {
-                    const refs = this.extractKubernetesRefsFromResource(resource);
-                    kubernetesRefsInResources.push(...refs);
-                }
-            }
-            return {
-                resourcesCreated,
-                kubernetesRefsInResources,
-                requiresCelConversion: kubernetesRefsInResources.length > 0,
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to analyze resource creation: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Process a composition's status shape for CEL conversion
-     */
-    processCompositionStatus(statusShape, factoryType = 'kro') {
-        if (factoryType === 'direct') {
-            // For direct factory, leave expressions as-is for runtime evaluation
-            return statusShape;
-        }
-        // Create analysis context
-        const analysisContext = {
-            type: 'status',
-            availableReferences: {},
-            factoryType,
-        };
-        // For Kro factory, convert KubernetesRef-containing expressions to CEL
-        return this.magicAssignableAnalyzer.analyzeMagicAssignableShape(statusShape, analysisContext).processedShape;
-    }
-    /**
-     * Enhanced status building with comprehensive KubernetesRef handling
-     */
-    buildCompositionStatus(statusShape, context, factoryType = 'kro') {
-        // Create analysis context
-        const analysisContext = {
-            type: 'status',
-            availableReferences: context.resources,
-            factoryType,
-        };
-        // Analyze the status shape for KubernetesRef objects
-        const analysisResult = this.magicAssignableAnalyzer.analyzeMagicAssignableShape(statusShape, analysisContext);
-        // Track context for dependency analysis
-        const contextTracking = this.contextTracker.trackCompositionContext(context);
-        // Extract dependencies from KubernetesRef objects
-        const dependencies = new Set();
-        let crossResourceReferences = 0;
-        for (const ref of analysisResult.dependencies) {
-            if (ref.resourceId !== '__schema__') {
-                dependencies.add(ref.resourceId);
-                // Check if this is a cross-resource reference
-                if (contextTracking.resourcesWithKubernetesRefs.includes(ref.resourceId)) {
-                    crossResourceReferences++;
-                }
-            }
-        }
-        // Process the status shape based on factory type
-        let processedStatus;
-        let celExpressionsGenerated = 0;
-        if (factoryType === 'direct') {
-            // For direct factory, leave expressions as-is for runtime evaluation
-            processedStatus = statusShape;
-        }
-        else {
-            // For Kro factory, convert KubernetesRef-containing expressions to CEL
-            processedStatus = analysisResult.processedShape;
-            celExpressionsGenerated = Object.keys(analysisResult.fieldResults).length;
-        }
-        return {
-            processedStatus,
-            kubernetesRefs: analysisResult.dependencies,
-            dependencies: Array.from(dependencies),
-            requiresCelConversion: analysisResult.dependencies.length > 0,
-            conversionMetadata: {
-                fieldsProcessed: Object.keys(analysisResult.fieldResults).length,
-                kubernetesRefsFound: analysisResult.dependencies.length,
-                celExpressionsGenerated,
-                crossResourceReferences,
-            },
-        };
-    }
-    /**
-     * Validate status shape for composition compatibility
-     */
-    validateStatusShape(statusShape, context) {
-        const errors = [];
-        const warnings = [];
-        try {
-            // Create analysis context
-            const analysisContext = {
-                type: 'status',
-                availableReferences: context?.resources || {},
-                factoryType: 'kro',
-            };
-            // Analyze the status shape
-            const analysisResult = this.magicAssignableAnalyzer.analyzeMagicAssignableShape(statusShape, analysisContext);
-            // Validate each KubernetesRef
-            for (const ref of analysisResult.dependencies) {
-                const scopeValidation = this.scopeManager.validateKubernetesRefScope(ref);
-                if (!scopeValidation.isValid) {
-                    errors.push(`Invalid KubernetesRef scope: ${scopeValidation.error}`);
-                }
-                // Check if the referenced resource exists in the context
-                if (context && ref.resourceId !== '__schema__' && !context.resources[ref.resourceId]) {
-                    warnings.push(`Referenced resource '${ref.resourceId}' not found in composition context`);
-                }
-            }
-            // Check for circular dependencies
-            if (context) {
-                const contextTracking = this.contextTracker.trackCompositionContext(context);
-                // Simple circular dependency detection
-                const resourceGraph = new Map();
-                for (const crossRef of contextTracking.crossResourceReferences) {
-                    if (!resourceGraph.has(crossRef.sourceResource)) {
-                        resourceGraph.set(crossRef.sourceResource, new Set());
-                    }
-                    resourceGraph.get(crossRef.sourceResource)?.add(crossRef.targetResource);
-                }
-                // Check for cycles using DFS
-                const visited = new Set();
-                const recursionStack = new Set();
-                const hasCycle = (node) => {
-                    if (recursionStack.has(node)) {
-                        return true;
-                    }
-                    if (visited.has(node)) {
-                        return false;
-                    }
-                    visited.add(node);
-                    recursionStack.add(node);
-                    const neighbors = resourceGraph.get(node) || new Set();
-                    for (const neighbor of neighbors) {
-                        if (hasCycle(neighbor)) {
-                            return true;
-                        }
-                    }
-                    recursionStack.delete(node);
-                    return false;
-                };
-                for (const resource of resourceGraph.keys()) {
-                    if (hasCycle(resource)) {
-                        errors.push(`Circular dependency detected involving resource '${resource}'`);
-                        break;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            errors.push(`Status shape validation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-            warnings,
-        };
-    }
-    /**
-     * Extract referenced resources from composition context
-     */
-    extractReferencedResources(context) {
-        if (!context) {
-            const currentContext = getCurrentCompositionContext();
-            if (!currentContext) {
-                return [];
-            }
-            context = currentContext;
-        }
-        return Object.keys(context.resources);
-    }
-    /**
-     * Extract KubernetesRef objects from a resource
-     */
-    extractKubernetesRefsFromResource(resource) {
-        const refs = [];
-        const traverse = (obj) => {
-            if (isKubernetesRef(obj)) {
-                refs.push(obj);
-                return;
-            }
-            if (Array.isArray(obj)) {
-                obj.forEach(traverse);
-            }
-            else if (obj && typeof obj === 'object') {
-                Object.values(obj).forEach(traverse);
-            }
-        };
-        traverse(resource);
-        return refs;
-    }
-}
-/**
- * Context-aware resource tracking for composition integration
- */
-export class CompositionContextTracker {
-    contextAnalysisCache = new Map();
-    resourceKubernetesRefCache = new Map();
-    /**
-     * Track KubernetesRef usage in a composition context
-     */
-    trackCompositionContext(context) {
-        const allKubernetesRefs = [];
-        const resourcesWithKubernetesRefs = [];
-        const crossResourceReferences = [];
-        // Analyze all resources in the context
-        for (const [resourceId, resource] of Object.entries(context.resources)) {
-            const refs = this.extractKubernetesRefsFromResource(resource);
-            if (refs.length > 0) {
-                resourcesWithKubernetesRefs.push(resourceId);
-                allKubernetesRefs.push(...refs);
-                // Cache the refs for this resource
-                this.resourceKubernetesRefCache.set(resourceId, refs);
-                // Identify cross-resource references
-                for (const ref of refs) {
-                    if (ref.resourceId !== resourceId && ref.resourceId !== '__schema__') {
-                        crossResourceReferences.push({
-                            sourceResource: resourceId,
-                            targetResource: ref.resourceId,
-                            fieldPath: ref.fieldPath,
-                        });
-                    }
-                }
-            }
-        }
-        return {
-            totalKubernetesRefs: allKubernetesRefs.length,
-            resourcesWithKubernetesRefs,
-            crossResourceReferences,
-        };
-    }
-    /**
-     * Get cached KubernetesRef objects for a resource
-     */
-    getCachedResourceKubernetesRefs(resourceId) {
-        return this.resourceKubernetesRefCache.get(resourceId) || [];
-    }
-    /**
-     * Clear caches for a specific context
-     */
-    clearContextCache(contextId) {
-        this.contextAnalysisCache.delete(contextId);
-    }
-    /**
-     * Extract KubernetesRef objects from a resource
-     */
-    extractKubernetesRefsFromResource(resource) {
-        const refs = [];
-        const traverse = (obj, path = '') => {
-            if (isKubernetesRef(obj)) {
-                refs.push(obj);
-                return;
-            }
-            if (Array.isArray(obj)) {
-                obj.forEach((item, index) => traverse(item, `${path}[${index}]`));
-            }
-            else if (obj && typeof obj === 'object') {
-                Object.entries(obj).forEach(([key, value]) => {
-                    const newPath = path ? `${path}.${key}` : key;
-                    traverse(value, newPath);
-                });
-            }
-        };
-        traverse(resource);
-        return refs;
-    }
-}
-/**
- * Magic proxy scoping manager for composition contexts with nested composition support
- */
-export class MagicProxyScopeManager {
-    scopeStack = [];
-    scopeRegistry = new Map();
-    /**
-     * Enter a new composition scope
-     */
-    enterScope(contextId, schemaProxy) {
-        const parentScope = this.getCurrentScope();
-        const depth = parentScope ? parentScope.depth + 1 : 0;
-        const newScope = {
-            contextId,
-            resourceIds: new Set(),
-            schemaProxy,
-            parentScope,
-            childScopes: [],
-            depth,
-        };
-        // Link to parent scope
-        if (parentScope) {
-            parentScope.childScopes.push(newScope);
-        }
-        this.scopeStack.push(newScope);
-        this.scopeRegistry.set(contextId, newScope);
-    }
-    /**
-     * Exit the current composition scope
-     */
-    exitScope() {
-        const exitingScope = this.scopeStack.pop();
-        if (exitingScope) {
-            this.scopeRegistry.delete(exitingScope.contextId);
-        }
-    }
-    /**
-     * Register a resource in the current scope
-     */
-    registerResource(resourceId) {
-        const currentScope = this.getCurrentScope();
-        if (currentScope) {
-            currentScope.resourceIds.add(resourceId);
-        }
-    }
-    /**
-     * Register merged resources from a nested composition
-     */
-    registerMergedResources(contextId, mergedResourceIds) {
-        const scope = this.scopeRegistry.get(contextId);
-        if (scope) {
-            scope.mergedResourceIds = mergedResourceIds;
-            // Also register these resources in the current scope for accessibility
-            const currentScope = this.getCurrentScope();
-            if (currentScope && currentScope !== scope) {
-                mergedResourceIds.forEach((id) => currentScope.resourceIds.add(id));
-            }
-        }
-    }
-    /**
-     * Get the current scope
-     */
-    getCurrentScope() {
-        return this.scopeStack[this.scopeStack.length - 1];
-    }
-    /**
-     * Get a scope by context ID
-     */
-    getScope(contextId) {
-        return this.scopeRegistry.get(contextId);
-    }
-    /**
-     * Check if a resource is accessible in the current scope (including parent scopes)
-     */
-    isResourceAccessible(resourceId) {
-        const currentScope = this.getCurrentScope();
-        if (!currentScope) {
-            return false;
-        }
-        // Check current scope and all parent scopes
-        let scope = currentScope;
-        while (scope) {
-            if (scope.resourceIds.has(resourceId)) {
-                return true;
-            }
-            // Check merged resources from nested compositions
-            if (scope.mergedResourceIds?.includes(resourceId)) {
-                return true;
-            }
-            scope = scope.parentScope;
-        }
-        return false;
-    }
-    /**
-     * Check if a resource is in the current scope only
-     */
-    isResourceInCurrentScope(resourceId) {
-        const currentScope = this.getCurrentScope();
-        return currentScope ? currentScope.resourceIds.has(resourceId) : false;
-    }
-    /**
-     * Get all accessible resources (current scope + parent scopes)
-     */
-    getAccessibleResources() {
-        const currentScope = this.getCurrentScope();
-        if (!currentScope) {
-            return [];
-        }
-        const accessibleResources = new Set();
-        // Collect resources from current scope and all parent scopes
-        let scope = currentScope;
-        while (scope) {
-            scope.resourceIds.forEach((id) => accessibleResources.add(id));
-            // Add merged resources from nested compositions
-            if (scope.mergedResourceIds) {
-                scope.mergedResourceIds.forEach((id) => accessibleResources.add(id));
-            }
-            scope = scope.parentScope;
-        }
-        return Array.from(accessibleResources);
-    }
-    /**
-     * Get resources in the current scope only
-     */
-    getCurrentScopeResources() {
-        const currentScope = this.getCurrentScope();
-        return currentScope ? Array.from(currentScope.resourceIds) : [];
-    }
-    /**
-     * Get the scope hierarchy as a string for debugging
-     */
-    getScopeHierarchy() {
-        const currentScope = this.getCurrentScope();
-        if (!currentScope) {
-            return 'No active scope';
-        }
-        const hierarchy = [];
-        let scope = currentScope;
-        while (scope) {
-            hierarchy.unshift(`${scope.contextId} (depth: ${scope.depth}, resources: ${scope.resourceIds.size})`);
-            scope = scope.parentScope;
-        }
-        return hierarchy.join(' -> ');
-    }
-    /**
-     * Validate KubernetesRef scope with nested composition support
-     */
-    validateKubernetesRefScope(kubernetesRef) {
-        const currentScope = this.getCurrentScope();
-        if (!currentScope) {
-            return { isValid: false, error: 'No active composition scope' };
-        }
-        // Schema references are always valid
-        if (kubernetesRef.resourceId === '__schema__') {
-            return { isValid: true };
-        }
-        // Check accessibility in nested scope hierarchy
-        let scope = currentScope;
-        while (scope) {
-            if (scope.resourceIds.has(kubernetesRef.resourceId)) {
-                return {
-                    isValid: true,
-                    scopeInfo: {
-                        foundInScope: scope.contextId,
-                        scopeDepth: scope.depth,
-                    },
-                };
-            }
-            // Check merged resources from nested compositions
-            if (scope.mergedResourceIds?.includes(kubernetesRef.resourceId)) {
-                return {
-                    isValid: true,
-                    scopeInfo: {
-                        foundInScope: scope.contextId,
-                        scopeDepth: scope.depth,
-                    },
-                };
-            }
-            scope = scope.parentScope;
-        }
-        return {
-            isValid: false,
-            error: `Resource '${kubernetesRef.resourceId}' is not accessible in the current composition scope hierarchy`,
-        };
-    }
-    /**
-     * Get nested composition statistics
-     */
-    getNestedCompositionStats() {
-        const currentScope = this.getCurrentScope();
-        const stats = {
-            totalScopes: this.scopeRegistry.size,
-            maxDepth: 0,
-            currentDepth: currentScope?.depth || 0,
-            totalResources: 0,
-            resourcesByScope: {},
-        };
-        for (const [contextId, scope] of this.scopeRegistry) {
-            stats.maxDepth = Math.max(stats.maxDepth, scope.depth);
-            stats.totalResources += scope.resourceIds.size;
-            stats.resourcesByScope[contextId] = scope.resourceIds.size;
-            if (scope.mergedResourceIds) {
-                stats.totalResources += scope.mergedResourceIds.length;
-            }
-        }
-        return stats;
-    }
-}
-/**
- * Integration hooks for kubernetesComposition API
- */
-export class CompositionIntegrationHooks {
-    analyzer;
-    contextTracker;
-    scopeManager;
-    constructor() {
-        this.analyzer = new CompositionExpressionAnalyzer();
-        this.contextTracker = new CompositionContextTracker();
-        this.scopeManager = new MagicProxyScopeManager();
-    }
-    /**
-     * Hook called before composition execution to set up expression analysis
-     */
-    beforeCompositionExecution(compositionFn, schemaProxy, contextId) {
-        // Enter the composition scope
-        this.scopeManager.enterScope(contextId, schemaProxy);
-        // Pre-analyze the composition for optimization opportunities
-        try {
-            const analysisResult = this.analyzer.analyzeCompositionFunction(compositionFn, schemaProxy);
-            // Store analysis result for later use during serialization
-            if (analysisResult.requiresCelConversion) {
-                console.debug(`Composition ${contextId} requires CEL conversion: ${analysisResult.conversionMetadata.kubernetesRefsDetected} KubernetesRef objects detected`);
-            }
-        }
-        catch (error) {
-            // Non-fatal error - composition can continue without pre-analysis
-            console.warn(`Composition pre-analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Hook called after composition execution to process results
-     */
-    afterCompositionExecution(statusShape, factoryType = 'kro', context) {
-        try {
-            // Track the composition context if provided
-            if (context) {
-                const trackingResult = this.contextTracker.trackCompositionContext(context);
-                if (trackingResult.crossResourceReferences.length > 0) {
-                    console.debug(`Composition has ${trackingResult.crossResourceReferences.length} cross-resource references that may require CEL conversion`);
-                }
-            }
-            // Process the status shape
-            const processedStatus = this.analyzer.processCompositionStatus(statusShape, factoryType);
-            return processedStatus;
-        }
-        finally {
-            // Exit the composition scope
-            this.scopeManager.exitScope();
-        }
-    }
-    /**
-     * Hook called during resource creation to analyze KubernetesRef usage
-     */
-    onResourceCreation(resourceId, resource, _context) {
-        // Register the resource in the current scope
-        this.scopeManager.registerResource(resourceId);
-        // Analyze KubernetesRef usage
-        const refs = this.contextTracker.getCachedResourceKubernetesRefs(resourceId) ||
-            this.contextTracker.extractKubernetesRefsFromResource(resource);
-        if (refs.length > 0) {
-            console.debug(`Resource ${resourceId} contains ${refs.length} KubernetesRef objects that may require CEL conversion`);
-            // Validate scope for each KubernetesRef
-            for (const ref of refs) {
-                const validation = this.scopeManager.validateKubernetesRefScope(ref);
-                if (!validation.isValid) {
-                    console.warn(`KubernetesRef validation failed for resource ${resourceId}: ${validation.error}`);
-                }
-            }
-        }
-    }
-    /**
-     * Get the current magic proxy scope manager
-     */
-    getScopeManager() {
-        return this.scopeManager;
-    }
-    /**
-     * Get the context tracker
-     */
-    getContextTracker() {
-        return this.contextTracker;
-    }
-    /**
-     * Handle auto-registration of resources with KubernetesRef tracking
-     */
-    handleAutoRegistration(resourceId, resource, context) {
-        // Register the resource in the current scope
-        this.scopeManager.registerResource(resourceId);
-        // Track KubernetesRef objects in the auto-registered resource
-        const refs = this.contextTracker.extractKubernetesRefsFromResource(resource);
-        if (refs.length > 0) {
-            // Validate that all referenced resources are accessible
-            for (const ref of refs) {
-                const validation = this.scopeManager.validateKubernetesRefScope(ref);
-                if (!validation.isValid) {
-                    console.warn(`Auto-registered resource '${resourceId}' contains invalid KubernetesRef: ${validation.error}`);
-                }
-            }
-            // Cache the KubernetesRef objects for later use
-            this.contextTracker.resourceKubernetesRefCache.set(resourceId, refs);
-        }
-        // Update the composition context
-        context.addResource(resourceId, resource);
-    }
-    /**
-     * Handle side-effect based resource creation with magic proxy integration
-     */
-    handleSideEffectCreation(resourceFactory, resourceId, context) {
-        const activeContext = context || getCurrentCompositionContext();
-        if (!activeContext) {
-            // No active composition context - create resource normally
-            return resourceFactory();
-        }
-        // Track resources before creation
-        const resourcesBefore = new Set(Object.keys(activeContext.resources));
-        // Create the resource
-        const resource = resourceFactory();
-        // Determine the actual resource ID
-        const actualResourceId = resourceId || this.generateResourceIdFromResource(resource);
-        // Check if new resources were created as side effects
-        const resourcesAfter = Object.keys(activeContext.resources);
-        const newResources = resourcesAfter.filter((id) => !resourcesBefore.has(id));
-        // Handle each new resource
-        for (const newResourceId of newResources) {
-            const newResource = activeContext.resources[newResourceId];
-            if (newResource) {
-                this.handleAutoRegistration(newResourceId, newResource, activeContext);
-            }
-        }
-        // Handle the main resource if it wasn't already registered
-        if (!activeContext.resources[actualResourceId]) {
-            this.handleAutoRegistration(actualResourceId, resource, activeContext);
-        }
-        return resource;
-    }
-    /**
-     * Track magic proxy usage during composition execution
-     */
-    trackMagicProxyUsage(proxyAccess) {
-        const currentScope = this.scopeManager.getCurrentScope();
-        if (!currentScope) {
-            return;
-        }
-        // Validate that the accessed resource is in scope
-        if (proxyAccess.resourceId !== '__schema__' &&
-            !this.scopeManager.isResourceAccessible(proxyAccess.resourceId)) {
-            console.warn(`Magic proxy access to out-of-scope resource: ${proxyAccess.resourceId}.${proxyAccess.fieldPath}`);
-        }
-        // Track KubernetesRef creation from magic proxy access
-        if (proxyAccess.accessType === 'read' && isKubernetesRef(proxyAccess.value)) {
-            const validation = this.scopeManager.validateKubernetesRefScope(proxyAccess.value);
-            if (!validation.isValid) {
-                console.warn(`Magic proxy created invalid KubernetesRef: ${validation.error}`);
-            }
-        }
-    }
-    /**
-     * Ensure compatibility with existing factory functions
-     */
-    ensureFactoryCompatibility(factoryFn, factoryName) {
-        const currentScope = this.scopeManager.getCurrentScope();
-        if (!currentScope) {
-            // No active composition - use factory normally
-            return factoryFn();
-        }
-        try {
-            // Execute factory with side-effect tracking
-            return this.handleSideEffectCreation(factoryFn, undefined, getCurrentCompositionContext());
-        }
-        catch (error) {
-            console.error(`Factory function '${factoryName}' failed in composition context: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
-        }
-    }
-    /**
-     * Generate a resource ID from a resource object
-     */
-    generateResourceIdFromResource(resource) {
-        // Try to extract ID from common resource properties
-        const resourceObj = resource;
-        if (resourceObj.__resourceId) {
-            return resourceObj.__resourceId;
-        }
-        if (resourceObj.metadata?.name) {
-            const kind = resourceObj.kind || 'resource';
-            return `${kind.toLowerCase()}-${resourceObj.metadata.name}`;
-        }
-        if (resourceObj.kind) {
-            return `${resourceObj.kind.toLowerCase()}-${Date.now()}`;
-        }
-        return `resource-${Date.now()}`;
-    }
-}
-/**
- * Global composition integration instance
- */
-export const compositionIntegration = new CompositionIntegrationHooks();
-/**
- * Utility function to check if a composition function uses KubernetesRef objects
- */
-export function compositionUsesKubernetesRefs(compositionFn, schemaProxy) {
-    const analyzer = new CompositionExpressionAnalyzer();
-    try {
-        const result = analyzer.analyzeCompositionFunction(compositionFn, schemaProxy);
-        return result.requiresCelConversion;
-    }
-    catch {
-        // If analysis fails, assume it might use KubernetesRef objects to be safe
-        return true;
-    }
-}
-/**
- * Utility function to get composition analysis metadata
- */
-export function getCompositionAnalysis(compositionFn, schemaProxy) {
-    const analyzer = new CompositionExpressionAnalyzer();
-    return analyzer.analyzeCompositionFunction(compositionFn, schemaProxy);
-}
-//# sourceMappingURL=composition-integration.js.map