typekro 0.2.1 → 0.3.0

package/dist/core/expressions/optionality-handler.d.ts

@@ -0,0 +1,503 @@
+/**
+ * Enhanced Type Optionality Handler for JavaScript to CEL Expression Conversion
+ *
+ * This module handles the mismatch between Enhanced type compile-time non-optionality
+ * and runtime optionality during field hydration. Enhanced types show fields as
+ * non-optional at compile time, but KubernetesRef objects might resolve to undefined
+ * during field hydration.
+ *
+ * Key Features:
+ * - Automatic null-safety detection for Enhanced type KubernetesRef objects
+ * - CEL expression generation with has() checks for potentially undefined fields
+ * - Support for optional chaining with Enhanced types that appear non-optional
+ * - Integration with field hydration timing to handle undefined-to-defined transitions
+ * - Context-aware optionality handling based on field hydration state
+ */
+import type { CelExpression, KubernetesRef } from '../types/common.js';
+import type { Enhanced } from '../types/kubernetes.js';
+import { ConversionError } from '../errors.js';
+import type { AnalysisContext, CelConversionResult } from './analyzer.js';
+/**
+ * Optionality analysis result for a KubernetesRef
+ */
+export interface OptionalityAnalysisResult {
+    /** The KubernetesRef being analyzed */
+    kubernetesRef: KubernetesRef<any>;
+    /** Whether this field might be undefined at runtime */
+    potentiallyUndefined: boolean;
+    /** Whether this field requires null-safety checks */
+    requiresNullSafety: boolean;
+    /** Whether optional chaining was used in the original expression */
+    hasOptionalChaining: boolean;
+    /** The field path being accessed */
+    fieldPath: string;
+    /** The resource ID being referenced */
+    resourceId: string;
+    /** Whether this is a schema reference */
+    isSchemaReference: boolean;
+    /** Confidence level of the optionality analysis (0-1) */
+    confidence: number;
+    /** Reason for the optionality determination */
+    reason: string;
+    /** Suggested CEL expression pattern for null-safety */
+    suggestedCelPattern: string | undefined;
+}
+/**
+ * Field hydration state information
+ */
+export interface FieldHydrationState {
+    /** Resource ID */
+    resourceId: string;
+    /** Field path */
+    fieldPath: string;
+    /** Whether the field is currently hydrated */
+    isHydrated: boolean;
+    /** Whether the field is in the process of being hydrated */
+    isHydrating: boolean;
+    /** Whether the field has failed hydration */
+    hydrationFailed: boolean;
+    /** Timestamp of last hydration attempt */
+    lastHydrationAttempt?: Date;
+    /** Expected hydration completion time */
+    expectedHydrationTime?: Date;
+}
+/**
+ * Optionality handling context
+ */
+export interface OptionalityContext extends AnalysisContext {
+    /** Current field hydration states */
+    hydrationStates?: Map<string, FieldHydrationState>;
+    /** Whether to be conservative with null-safety (default: true) */
+    conservativeNullSafety?: boolean;
+    /** Whether to use Kro's conditional operators */
+    useKroConditionals?: boolean;
+    /** Whether to generate has() checks for potentially undefined fields */
+    generateHasChecks?: boolean;
+    /** Maximum depth for optionality analysis */
+    maxOptionalityDepth?: number;
+}
+/**
+ * Optional chaining pattern information
+ */
+export interface OptionalChainingPattern {
+    /** The KubernetesRef involved in optional chaining */
+    kubernetesRef: KubernetesRef<any>;
+    /** Field path being accessed */
+    fieldPath: string;
+    /** Whether this is an Enhanced type */
+    isEnhancedType: boolean;
+    /** Whether the field appears non-optional at compile time */
+    appearsNonOptional: boolean;
+    /** Whether the field is actually optional at runtime */
+    actuallyOptional: boolean;
+    /** Depth of the chaining (number of dots) */
+    chainingDepth: number;
+    /** Suggested CEL pattern for this optional chaining */
+    suggestedCelPattern: string;
+}
+/**
+ * Enhanced type field information
+ */
+export interface EnhancedTypeFieldInfo {
+    /** The KubernetesRef for this field */
+    kubernetesRef: KubernetesRef<any>;
+    /** Field path */
+    fieldPath: string;
+    /** Whether this is an Enhanced type */
+    isEnhancedType: boolean;
+    /** Whether the field appears non-optional at compile time */
+    appearsNonOptional: boolean;
+    /** Whether the field is actually optional at runtime */
+    actuallyOptional: boolean;
+    /** Whether this is a status field */
+    isStatusField: boolean;
+    /** Whether this field requires optional chaining handling */
+    requiresOptionalChaining: boolean;
+    /** Confidence level of the analysis */
+    confidence: number;
+}
+/**
+ * Hydration state analysis result
+ */
+export interface HydrationStateAnalysis {
+    /** References that are not yet hydrated */
+    unhydratedRefs: KubernetesRef<any>[];
+    /** References that are fully hydrated */
+    hydratedRefs: KubernetesRef<any>[];
+    /** References that are currently being hydrated */
+    hydratingRefs: KubernetesRef<any>[];
+    /** References that failed hydration */
+    failedRefs: KubernetesRef<any>[];
+    /** Total number of references */
+    totalRefs: number;
+    /** Hydration progress (0-1) */
+    hydrationProgress: number;
+}
+/**
+ * Hydration transition plan
+ */
+export interface HydrationTransitionPlan {
+    /** Hydration phases in order */
+    phases: HydrationPhase[];
+    /** Total expected duration for all phases */
+    totalDuration: number;
+    /** Critical fields that must be hydrated for the expression to work */
+    criticalFields: string[];
+}
+/**
+ * Hydration phase information
+ */
+export interface HydrationPhase {
+    /** Phase name */
+    name: string;
+    /** Fields expected to be hydrated in this phase */
+    fields: KubernetesRef<any>[];
+    /** Expected duration for this phase (milliseconds) */
+    expectedDuration: number;
+    /** Dependencies that must be satisfied before this phase */
+    dependencies: string[];
+    /** Whether this phase is critical for expression evaluation */
+    isCritical: boolean;
+}
+/**
+ * Hydration transition handler
+ */
+export interface HydrationTransitionHandler {
+    /** State transitioning from */
+    fromState: HydrationState;
+    /** State transitioning to */
+    toState: HydrationState;
+    /** Condition that triggers this transition */
+    triggerCondition: string;
+    /** Expression to use during this transition */
+    transitionExpression: CelExpression;
+    /** Priority of this handler (lower = higher priority) */
+    priority: number;
+}
+/**
+ * Hydration state
+ */
+export type HydrationState = 'unhydrated' | 'hydrating' | 'hydrated' | 'failed';
+/**
+ * Result of undefined-to-defined transition handling
+ */
+export interface UndefinedToDefinedTransitionResult {
+    /** Transition plan for hydration phases */
+    transitionPlan: HydrationTransitionPlan;
+    /** Expressions for each hydration phase */
+    phaseExpressions: Map<string, CelExpression>;
+    /** Watch expressions for monitoring hydration progress */
+    watchExpressions: CelExpression[];
+    /** Fallback expressions for hydration failures */
+    fallbackExpressions: Map<string, CelExpression>;
+    /** Whether the transition handling was successful */
+    valid: boolean;
+    /** Errors encountered during transition handling */
+    errors: ConversionError[];
+}
+/**
+ * Options for optionality handling
+ */
+export interface OptionalityHandlingOptions {
+    /** Whether to perform deep optionality analysis */
+    deepAnalysis?: boolean;
+    /** Whether to be conservative with null-safety */
+    conservative?: boolean;
+    /** Whether to use Kro's conditional operators */
+    useKroConditionals?: boolean;
+    /** Whether to generate has() checks */
+    generateHasChecks?: boolean;
+    /** Maximum analysis depth */
+    maxDepth?: number;
+    /** Whether to include detailed reasoning */
+    includeReasoning?: boolean;
+}
+/**
+ * Enhanced Type Optionality Handler
+ *
+ * Handles the complexity of Enhanced types that appear non-optional at compile time
+ * but may be undefined at runtime during field hydration.
+ */
+export declare class EnhancedTypeOptionalityHandler {
+    private options;
+    private logger;
+    constructor(options?: OptionalityHandlingOptions);
+    /**
+     * Analyze KubernetesRef objects for optionality requirements
+     *
+     * This method determines whether KubernetesRef objects in expressions require
+     * null-safety handling based on Enhanced type behavior and field hydration timing.
+     */
+    analyzeOptionalityRequirements(expression: any, context: OptionalityContext): OptionalityAnalysisResult[];
+    /**
+     * Generate CEL expressions with appropriate null-safety checks
+     *
+     * This method takes the optionality analysis results and generates CEL expressions
+     * that include proper null-safety handling for potentially undefined fields.
+     */
+    generateNullSafeCelExpression(originalExpression: any, optionalityResults: OptionalityAnalysisResult[], context: OptionalityContext): CelConversionResult;
+    /**
+     * Handle optional chaining with Enhanced types
+     *
+     * This method specifically handles cases where optional chaining is used with
+     * Enhanced types that appear non-optional at compile time.
+     */
+    handleOptionalChainingWithEnhancedTypes(expression: any, context: OptionalityContext): CelConversionResult;
+    /**
+     * Analyze optional chaining patterns in expressions with Enhanced types
+     */
+    private analyzeOptionalChainingPatterns;
+    /**
+     * Analyze Enhanced type field information
+     */
+    private analyzeEnhancedTypeField;
+    /**
+     * Generate CEL expression for optional chaining with Enhanced types
+     */
+    private generateOptionalChainingCelExpression;
+    /**
+     * Generate Kro CEL expression with ? prefix operator for optional chaining
+     *
+     * Kro uses the ? operator as a prefix before field names for optional access
+     */
+    private generateKroOptionalChainingExpression;
+    /**
+     * Convert a field path to Kro's ? prefix optional syntax
+     * Example: resources.service.status.loadBalancer.ingress[0].ip
+     * Becomes: resources.service.status.?loadBalancer.?ingress[0].?ip
+     *
+     * The ? operator should be placed before fields that might not exist
+     */
+    private convertToKroOptionalSyntax;
+    /**
+     * Generate has() check expression for optional chaining
+     */
+    private generateHasCheckOptionalChainingExpression;
+    /**
+     * Generate nested has() checks for a field path
+     */
+    private generateNestedHasChecksForPath;
+    /**
+     * Calculate chaining depth for a field path
+     */
+    private calculateChainingDepth;
+    /**
+     * Generate optional chaining CEL pattern for a KubernetesRef
+     */
+    private generateOptionalChainingCelPattern;
+    /**
+     * Automatically detect null-safety requirements for Enhanced type KubernetesRef objects
+     *
+     * This method analyzes Enhanced types and their KubernetesRef objects to determine
+     * which fields require null-safety checks despite appearing non-optional at compile time.
+     */
+    detectNullSafetyRequirements(enhancedResources: Record<string, Enhanced<any, any>>, context: OptionalityContext): Map<string, OptionalityAnalysisResult[]>;
+    /**
+     * Generate Enhanced type-specific null-safety patterns
+     */
+    private generateEnhancedTypeNullSafetyPattern;
+    /**
+     * Extract potential KubernetesRef objects from Enhanced resources
+     */
+    private extractPotentialKubernetesRefsFromEnhanced;
+    /**
+     * Integrate with field hydration timing
+     *
+     * This method provides integration with TypeKro's field hydration system to
+     * handle the transition from undefined to defined values during hydration.
+     */
+    integrateWithFieldHydrationTiming(expression: any, hydrationStates: Map<string, FieldHydrationState>, context: OptionalityContext): {
+        preHydrationExpression: CelExpression | null;
+        postHydrationExpression: CelExpression | null;
+        hydrationDependentExpression: CelExpression | null;
+        transitionHandlers: HydrationTransitionHandler[];
+    };
+    /**
+     * Handle undefined-to-defined transitions during field hydration
+     *
+     * This method creates handlers for the transition from undefined to defined
+     * values as fields are hydrated over time.
+     */
+    handleUndefinedToDefinedTransitions(expression: any, hydrationStates: Map<string, FieldHydrationState>, context: OptionalityContext): UndefinedToDefinedTransitionResult;
+    /**
+     * Analyze hydration states for KubernetesRef objects
+     */
+    private analyzeHydrationStates;
+    /**
+     * Create transition plan for hydration phases
+     */
+    private createTransitionPlan;
+    /**
+     * Generate hydration transition handlers
+     */
+    private generateHydrationTransitionHandlers;
+    /**
+     * Generate phase expressions for different hydration phases
+     */
+    private generatePhaseExpressions;
+    /**
+     * Generate watch expressions for monitoring hydration progress
+     */
+    private generateWatchExpressions;
+    /**
+     * Generate fallback expressions for hydration failures
+     */
+    private generateFallbackExpressions;
+    /**
+     * Generate phase-specific expression
+     */
+    private generatePhaseSpecificExpression;
+    /**
+     * Generate condition for hydration start
+     */
+    private generateHydrationStartCondition;
+    /**
+     * Generate expression for hydration start
+     */
+    private generateHydrationStartExpression;
+    /**
+     * Generate condition for hydration complete
+     */
+    private generateHydrationCompleteCondition;
+    /**
+     * Generate expression for hydration complete
+     */
+    private generateHydrationCompleteExpression;
+    /**
+     * Generate condition for hydration failure
+     */
+    private generateHydrationFailureCondition;
+    /**
+     * Generate expression for hydration failure
+     */
+    private generateHydrationFailureExpression;
+    /**
+     * Analyze a single KubernetesRef for optionality requirements
+     */
+    private analyzeKubernetesRefOptionality;
+    /**
+     * Determine if a KubernetesRef is potentially undefined at runtime
+     */
+    private isPotentiallyUndefinedAtRuntime;
+    /**
+     * Check if a schema field is potentially undefined
+     */
+    private isSchemaFieldPotentiallyUndefined;
+    /**
+     * Check if a status field is potentially undefined
+     */
+    private isStatusFieldPotentiallyUndefined;
+    /**
+     * Check if a spec field is potentially undefined
+     */
+    private isSpecFieldPotentiallyUndefined;
+    /**
+     * Check if a metadata field is potentially undefined
+     */
+    private isMetadataFieldPotentiallyUndefined;
+    /**
+     * Check if optional chaining was used in the original expression
+     */
+    private hasOptionalChainingInExpression;
+    /**
+     * Calculate confidence level for optionality analysis
+     */
+    private calculateOptionalityConfidence;
+    /**
+     * Determine the reason for optionality determination
+     */
+    private determineOptionalityReason;
+    /**
+     * Generate suggested CEL pattern for null-safety
+     */
+    private generateSuggestedCelPattern;
+    /**
+     * Extract KubernetesRef objects from an expression
+     */
+    private extractKubernetesRefs;
+    /**
+     * Convert expression to basic CEL without null-safety
+     */
+    private convertToBasicCel;
+    /**
+     * Generate CEL expressions with has() checks for potentially undefined fields
+     *
+     * This method creates comprehensive CEL expressions that include has() checks
+     * for all potentially undefined fields in the expression.
+     */
+    generateCelWithHasChecks(expression: any, optionalityResults: OptionalityAnalysisResult[], context: OptionalityContext): CelExpression;
+    /**
+     * Generate has() checks for fields that require null-safety
+     */
+    private generateHasChecksForFields;
+    /**
+     * Generate nested has() checks for complex field paths
+     */
+    private generateNestedHasChecks;
+    /**
+     * Convert expression with KubernetesRef objects to CEL
+     */
+    private convertExpressionWithKubernetesRefs;
+    /**
+     * Combine has() checks with the main expression
+     */
+    private combineHasChecksWithExpression;
+    /**
+     * Infer the type of the expression result
+     */
+    private inferExpressionType;
+    /**
+     * Generate null-safe CEL expression
+     */
+    private generateNullSafeExpression;
+    /**
+     * Generate source mapping for debugging
+     */
+    private generateSourceMapping;
+    /**
+     * Generate pre-hydration expression (for unhydrated fields)
+     */
+    private generatePreHydrationExpression;
+    /**
+     * Generate post-hydration expression (for hydrated fields)
+     */
+    private generatePostHydrationExpression;
+    /**
+     * Generate hydration-dependent expression (for fields being hydrated)
+     */
+    private generateHydrationDependentExpression;
+}
+/**
+ * Convenience function to analyze optionality requirements
+ */
+export declare function analyzeOptionalityRequirements(expression: any, context: OptionalityContext, options?: OptionalityHandlingOptions): OptionalityAnalysisResult[];
+/**
+ * Convenience function to generate null-safe CEL expressions
+ */
+export declare function generateNullSafeCelExpression(expression: any, optionalityResults: OptionalityAnalysisResult[], context: OptionalityContext, options?: OptionalityHandlingOptions): CelConversionResult;
+/**
+ * Convenience function to handle optional chaining with Enhanced types
+ */
+export declare function handleOptionalChainingWithEnhancedTypes(expression: any, context: OptionalityContext, options?: OptionalityHandlingOptions): CelConversionResult;
+/**
+ * Convenience function to generate CEL expressions with has() checks
+ */
+export declare function generateCelWithHasChecks(expression: any, optionalityResults: OptionalityAnalysisResult[], context: OptionalityContext, options?: OptionalityHandlingOptions): CelExpression;
+/**
+ * Convenience function to detect null-safety requirements for Enhanced types
+ */
+export declare function detectNullSafetyRequirements(enhancedResources: Record<string, Enhanced<any, any>>, context: OptionalityContext, options?: OptionalityHandlingOptions): Map<string, OptionalityAnalysisResult[]>;
+/**
+ * Convenience function to integrate with field hydration timing
+ */
+export declare function integrateWithFieldHydrationTiming(expression: any, hydrationStates: Map<string, FieldHydrationState>, context: OptionalityContext, options?: OptionalityHandlingOptions): {
+    preHydrationExpression: CelExpression | null;
+    postHydrationExpression: CelExpression | null;
+    hydrationDependentExpression: CelExpression | null;
+    transitionHandlers: HydrationTransitionHandler[];
+};
+/**
+ * Convenience function to handle undefined-to-defined transitions
+ */
+export declare function handleUndefinedToDefinedTransitions(expression: any, hydrationStates: Map<string, FieldHydrationState>, context: OptionalityContext, options?: OptionalityHandlingOptions): UndefinedToDefinedTransitionResult;
+//# sourceMappingURL=optionality-handler.d.ts.map

package/dist/core/expressions/optionality-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionality-handler.d.ts","sourceRoot":"","sources":["../../../src/core/expressions/optionality-handler.ts"],"names":[],"mappings":"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"}