typekro 0.3.1 → 0.5.0

package/dist/core/expressions/{type-inference.js → validation/type-inference.js}

@@ -5,47 +5,13 @@
  * generated from JavaScript expressions. It analyzes CEL expressions
  * to determine their result types and validates type compatibility.
  */
-/**
- * Type inference error
- */
-export class TypeInferenceError extends Error {
-    celExpression;
-    location;
-    constructor(message, celExpression, location) {
-        super(message);
-        this.celExpression = celExpression;
-        this.location = location;
-        this.name = 'TypeInferenceError';
-    }
-    static forUnknownFunction(celExpression, functionName, location) {
-        return new TypeInferenceError(`Unknown CEL function: ${functionName}`, celExpression, location);
-    }
-    static forIncompatibleOperands(celExpression, operator, leftType, rightType, location) {
-        return new TypeInferenceError(`Incompatible operands for operator '${operator}': ${leftType.typeName} and ${rightType.typeName}`, celExpression, location);
-    }
-    static forUnresolvableReference(celExpression, reference, location) {
-        return new TypeInferenceError(`Cannot resolve reference: ${reference}`, celExpression, location);
-    }
-}
-/**
- * Type inference warning
- */
-export class TypeInferenceWarning {
-    message;
-    celExpression;
-    location;
-    constructor(message, celExpression, location) {
-        this.message = message;
-        this.celExpression = celExpression;
-        this.location = location;
-    }
-    static forPotentialNullDereference(celExpression, reference, location) {
-        return new TypeInferenceWarning(`Potential null dereference: ${reference}`, celExpression, location);
-    }
-    static forImplicitTypeConversion(celExpression, fromType, toType, location) {
-        return new TypeInferenceWarning(`Implicit type conversion from ${fromType} to ${toType}`, celExpression, location);
-    }
-}
+import { ensureError } from '../../errors.js';
+import { inferResourceFieldType, inferSchemaFieldType } from './kubernetes-field-types.js';
+import { TypeInferenceError, TypeInferenceWarning } from './type-inference-types.js';
+import { TypeValidationError } from './type-safety.js';
+export { getMetadataFieldType, getSpecFieldType, getStatusFieldType, inferResourceFieldType, inferSchemaFieldType, inferTypeFromValue, } from './kubernetes-field-types.js';
+// Re-export everything from sub-modules for backward compatibility
+export { TypeInferenceError, TypeInferenceWarning, } from './type-inference-types.js';
 /**
  * CEL type inference engine
  */
@@ -68,17 +34,19 @@ export class CelTypeInferenceEngine {
                 errors: result.errors,
                 warnings: result.warnings,
                 confidence: result.confidence,
-                metadata: result.metadata
+                metadata: result.metadata,
             };
         }
         catch (error) {
             return {
                 resultType: { typeName: 'unknown', optional: false, nullable: false },
                 success: false,
-                errors: [new TypeInferenceError(`Type inference failed: ${error instanceof Error ? error.message : String(error)}`, celExpression.expression)],
+                errors: [
+                    new TypeInferenceError(`Type inference failed: ${ensureError(error).message}`, celExpression.expression),
+                ],
                 warnings: [],
                 confidence: 0,
-                metadata: this.createEmptyMetadata()
+                metadata: this.createEmptyMetadata(),
             };
         }
     }
@@ -86,7 +54,7 @@ export class CelTypeInferenceEngine {
      * Infer types for multiple CEL expressions
      */
     inferTypes(celExpressions, context) {
-        return celExpressions.map(expr => this.inferType(expr, context));
+        return celExpressions.map((expr) => this.inferType(expr, context));
     }
     /**
      * Validate type compatibility between expressions
@@ -101,7 +69,7 @@ export class CelTypeInferenceEngine {
                 resultType: targetType,
                 errors: [],
                 warnings: [],
-                suggestions: []
+                suggestions: [],
             };
         }
         // Check assignability
@@ -113,8 +81,8 @@ export class CelTypeInferenceEngine {
                 valid: true,
                 resultType: targetType,
                 errors: [],
-                warnings: warnings.map(w => ({ message: w.message, expression: w.celExpression })),
-                suggestions: []
+                warnings: warnings.map((w) => ({ message: w.message, expression: w.celExpression })),
+                suggestions: [],
             };
         }
         // Type mismatch
@@ -122,15 +90,9 @@ export class CelTypeInferenceEngine {
         return {
             valid: false,
             resultType: targetType,
-            errors: errors.map(e => ({
-                message: e.message,
-                expression: e.celExpression,
-                expectedType: targetType,
-                actualType: sourceType,
-                name: 'TypeValidationError'
-            })),
+            errors: errors.map((e) => new TypeValidationError(e.message, e.celExpression, targetType, sourceType)),
             warnings: [],
-            suggestions: [`Convert ${sourceType.typeName} to ${targetType.typeName}`]
+            suggestions: [`Convert ${sourceType.typeName} to ${targetType.typeName}`],
         };
     }
     /**
@@ -169,7 +131,7 @@ export class CelTypeInferenceEngine {
             errors,
             warnings,
             confidence: 0.1,
-            metadata
+            metadata,
         };
     }
     /**
@@ -187,7 +149,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const operator = tokens[operatorIndex];
@@ -198,7 +160,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const leftTokens = tokens.slice(0, operatorIndex);
@@ -215,7 +177,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         // Validate operand types
@@ -227,7 +189,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         // Combine metadata
@@ -238,7 +200,7 @@ export class CelTypeInferenceEngine {
             errors: [...errors, ...leftResult.errors, ...rightResult.errors],
             warnings: [...warnings, ...leftResult.warnings, ...rightResult.warnings],
             confidence: Math.min(leftResult.confidence, rightResult.confidence) * 0.9,
-            metadata
+            metadata,
         };
     }
     /**
@@ -257,7 +219,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const functionName = functionMatch[1];
@@ -268,7 +230,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const functionSignature = this.functionTypes.get(functionName);
@@ -279,7 +241,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         metadata.functionsUsed.push(functionName);
@@ -289,7 +251,7 @@ export class CelTypeInferenceEngine {
             errors,
             warnings,
             confidence: 0.8,
-            metadata
+            metadata,
         };
     }
     /**
@@ -309,7 +271,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const [, resourceId, fieldPath] = match;
@@ -320,7 +282,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         // Look up resource type
@@ -332,11 +294,11 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
-        // Infer field type
-        const fieldType = this.inferResourceFieldType(resource, fieldPath);
+        // Infer field type using standalone function
+        const fieldType = inferResourceFieldType(resource, fieldPath);
         // Check for optional chaining
         if (reference.includes('?')) {
             metadata.usesOptionalChaining = true;
@@ -347,7 +309,7 @@ export class CelTypeInferenceEngine {
             errors,
             warnings,
             confidence: 0.9,
-            metadata
+            metadata,
         };
     }
     /**
@@ -367,7 +329,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const [, fieldPath] = match;
@@ -378,17 +340,17 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
-        // Infer schema field type
-        const fieldType = this.inferSchemaFieldType(context.schemaProxy, fieldPath);
+        // Infer schema field type using standalone function
+        const fieldType = inferSchemaFieldType(context.schemaProxy, fieldPath);
         return {
             type: fieldType,
             errors,
             warnings,
             confidence: 0.9,
-            metadata
+            metadata,
         };
     }
     /**
@@ -403,7 +365,7 @@ export class CelTypeInferenceEngine {
                 errors: [],
                 warnings: [],
                 confidence: 1.0,
-                metadata
+                metadata,
             };
         }
         // Number literals
@@ -413,7 +375,7 @@ export class CelTypeInferenceEngine {
                 errors: [],
                 warnings: [],
                 confidence: 1.0,
-                metadata
+                metadata,
             };
         }
         // Boolean literals
@@ -423,7 +385,7 @@ export class CelTypeInferenceEngine {
                 errors: [],
                 warnings: [],
                 confidence: 1.0,
-                metadata
+                metadata,
             };
         }
         // Null literal
@@ -433,7 +395,7 @@ export class CelTypeInferenceEngine {
                 errors: [],
                 warnings: [],
                 confidence: 1.0,
-                metadata
+                metadata,
             };
         }
         // Unknown literal
@@ -442,7 +404,7 @@ export class CelTypeInferenceEngine {
             errors: [],
             warnings: [],
             confidence: 0.5,
-            metadata
+            metadata,
         };
     }
     /**
@@ -461,7 +423,7 @@ export class CelTypeInferenceEngine {
                 errors,
                 warnings,
                 confidence: 0,
-                metadata
+                metadata,
             };
         }
         const conditionTokens = tokens.slice(0, questionIndex);
@@ -478,9 +440,14 @@ export class CelTypeInferenceEngine {
         return {
             type: resultType,
             errors: [...errors, ...conditionResult.errors, ...trueResult.errors, ...falseResult.errors],
-            warnings: [...warnings, ...conditionResult.warnings, ...trueResult.warnings, ...falseResult.warnings],
+            warnings: [
+                ...warnings,
+                ...conditionResult.warnings,
+                ...trueResult.warnings,
+                ...falseResult.warnings,
+            ],
             confidence: Math.min(conditionResult.confidence, trueResult.confidence, falseResult.confidence) * 0.9,
-            metadata
+            metadata,
         };
     }
     /**
@@ -491,48 +458,48 @@ export class CelTypeInferenceEngine {
         this.operatorTypes.set('>', {
             leftType: { typeName: 'number', optional: false, nullable: false },
             rightType: { typeName: 'number', optional: false, nullable: false },
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         this.operatorTypes.set('<', {
             leftType: { typeName: 'number', optional: false, nullable: false },
             rightType: { typeName: 'number', optional: false, nullable: false },
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         this.operatorTypes.set('==', {
             leftType: { typeName: 'any', optional: false, nullable: false },
             rightType: { typeName: 'any', optional: false, nullable: false },
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         this.operatorTypes.set('!=', {
             leftType: { typeName: 'any', optional: false, nullable: false },
             rightType: { typeName: 'any', optional: false, nullable: false },
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         // Logical operators
         this.operatorTypes.set('&&', {
             leftType: { typeName: 'boolean', optional: false, nullable: false },
             rightType: { typeName: 'boolean', optional: false, nullable: false },
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         this.operatorTypes.set('||', {
             leftType: { typeName: 'boolean', optional: false, nullable: false },
             rightType: { typeName: 'boolean', optional: false, nullable: false },
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         // Arithmetic operators
         this.operatorTypes.set('+', {
             leftType: { typeName: 'number', optional: false, nullable: false },
             rightType: { typeName: 'number', optional: false, nullable: false },
-            returnType: { typeName: 'number', optional: false, nullable: false }
+            returnType: { typeName: 'number', optional: false, nullable: false },
         });
         // CEL functions
         this.functionTypes.set('has', {
             parameters: [{ typeName: 'string', optional: false, nullable: false }],
-            returnType: { typeName: 'boolean', optional: false, nullable: false }
+            returnType: { typeName: 'boolean', optional: false, nullable: false },
         });
         this.functionTypes.set('size', {
             parameters: [{ typeName: 'any', optional: false, nullable: false }],
-            returnType: { typeName: 'number', optional: false, nullable: false }
+            returnType: { typeName: 'number', optional: false, nullable: false },
         });
     }
     /**
@@ -540,10 +507,10 @@ export class CelTypeInferenceEngine {
      */
     tokenizeExpression(expression) {
         // Simple tokenization - would need more sophisticated parsing for production
-        return expression.split(/\s+/).filter(token => token.length > 0);
+        return expression.split(/\s+/).filter((token) => token.length > 0);
     }
     isBinaryOperation(tokens) {
-        return tokens.some(token => ['>', '<', '>=', '<=', '==', '!=', '&&', '||', '+', '-', '*', '/'].includes(token));
+        return tokens.some((token) => ['>', '<', '>=', '<=', '==', '!=', '&&', '||', '+', '-', '*', '/'].includes(token));
     }
     isFunctionCall(tokens) {
         const expression = tokens.join(' ');
@@ -592,207 +559,7 @@ export class CelTypeInferenceEngine {
         return false;
     }
     requiresImplicitConversion(sourceType, targetType) {
-        return sourceType.typeName !== targetType.typeName &&
-            targetType.typeName !== 'any';
-    }
-    inferResourceFieldType(resource, fieldPath) {
-        try {
-            const parts = fieldPath.split('.');
-            // Handle common Kubernetes resource field patterns
-            if (parts[0] === 'metadata') {
-                return this.getMetadataFieldType(parts.slice(1));
-            }
-            if (parts[0] === 'spec') {
-                return this.getSpecFieldType(resource, parts.slice(1));
-            }
-            if (parts[0] === 'status') {
-                return this.getStatusFieldType(resource, parts.slice(1));
-            }
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-        catch (_error) {
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-    }
-    getMetadataFieldType(fieldParts) {
-        const fieldName = fieldParts[0];
-        if (!fieldName) {
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-        // Common metadata fields
-        const metadataTypes = {
-            'name': { typeName: 'string', optional: false, nullable: false },
-            'namespace': { typeName: 'string', optional: true, nullable: false },
-            'labels': { typeName: 'Record<string, string>', optional: true, nullable: false },
-            'annotations': { typeName: 'Record<string, string>', optional: true, nullable: false },
-            'uid': { typeName: 'string', optional: true, nullable: false },
-            'resourceVersion': { typeName: 'string', optional: true, nullable: false },
-            'generation': { typeName: 'number', optional: true, nullable: false },
-            'creationTimestamp': { typeName: 'string', optional: true, nullable: false }
-        };
-        if (fieldName in metadataTypes) {
-            const baseType = metadataTypes[fieldName];
-            if (!baseType) {
-                return { typeName: 'string', optional: true, nullable: false };
-            }
-            // Handle nested access (e.g., labels.app)
-            if (fieldParts.length > 1) {
-                if (baseType.typeName.startsWith('Record<')) {
-                    return { typeName: 'string', optional: true, nullable: false };
-                }
-            }
-            return baseType;
-        }
-        return { typeName: 'string', optional: true, nullable: false };
-    }
-    getSpecFieldType(resource, fieldParts) {
-        const resourceKind = resource.constructor.name;
-        const fieldName = fieldParts[0];
-        if (!fieldName) {
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-        // Common spec fields by resource type
-        const specFieldTypes = {
-            'Deployment': {
-                'replicas': { typeName: 'number', optional: true, nullable: false },
-                'selector': { typeName: 'object', optional: false, nullable: false },
-                'template': { typeName: 'object', optional: false, nullable: false },
-                'strategy': { typeName: 'object', optional: true, nullable: false }
-            },
-            'Service': {
-                'type': { typeName: 'string', optional: true, nullable: false },
-                'ports': { typeName: 'array', optional: false, nullable: false },
-                'selector': { typeName: 'Record<string, string>', optional: true, nullable: false },
-                'clusterIP': { typeName: 'string', optional: true, nullable: false }
-            },
-            'ConfigMap': {
-                'data': { typeName: 'Record<string, string>', optional: true, nullable: false },
-                'binaryData': { typeName: 'Record<string, string>', optional: true, nullable: false }
-            }
-        };
-        const resourceFields = specFieldTypes[resourceKind];
-        if (resourceFields && fieldName in resourceFields) {
-            const baseType = resourceFields[fieldName];
-            // Handle nested access
-            if (fieldParts.length > 1 && baseType) {
-                if (baseType.typeName.startsWith('Record<')) {
-                    return { typeName: 'string', optional: true, nullable: false };
-                }
-                if (baseType.typeName === 'array') {
-                    return { typeName: 'object', optional: true, nullable: false };
-                }
-                if (baseType.typeName === 'object') {
-                    return { typeName: 'unknown', optional: true, nullable: false };
-                }
-            }
-            return baseType || { typeName: 'unknown', optional: true, nullable: false };
-        }
-        return { typeName: 'unknown', optional: true, nullable: false };
-    }
-    getStatusFieldType(resource, fieldParts) {
-        const resourceKind = resource.constructor.name;
-        const fieldName = fieldParts[0];
-        if (!fieldName) {
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-        // Common status fields by resource type
-        const statusFieldTypes = {
-            'Deployment': {
-                'replicas': { typeName: 'number', optional: true, nullable: false },
-                'readyReplicas': { typeName: 'number', optional: true, nullable: false },
-                'availableReplicas': { typeName: 'number', optional: true, nullable: false },
-                'unavailableReplicas': { typeName: 'number', optional: true, nullable: false },
-                'updatedReplicas': { typeName: 'number', optional: true, nullable: false },
-                'conditions': { typeName: 'array', optional: true, nullable: false },
-                'observedGeneration': { typeName: 'number', optional: true, nullable: false }
-            },
-            'Service': {
-                'loadBalancer': { typeName: 'object', optional: true, nullable: false },
-                'conditions': { typeName: 'array', optional: true, nullable: false }
-            },
-            'Pod': {
-                'phase': { typeName: 'string', optional: true, nullable: false },
-                'conditions': { typeName: 'array', optional: true, nullable: false },
-                'hostIP': { typeName: 'string', optional: true, nullable: false },
-                'podIP': { typeName: 'string', optional: true, nullable: false },
-                'startTime': { typeName: 'string', optional: true, nullable: false },
-                'containerStatuses': { typeName: 'array', optional: true, nullable: false }
-            }
-        };
-        const resourceFields = statusFieldTypes[resourceKind];
-        if (resourceFields && fieldName in resourceFields) {
-            const baseType = resourceFields[fieldName];
-            // Handle nested access
-            if (fieldParts.length > 1 && baseType) {
-                if (baseType.typeName === 'object') {
-                    // Handle specific nested objects
-                    if (fieldName === 'loadBalancer' && fieldParts[1] === 'ingress') {
-                        return { typeName: 'array', optional: true, nullable: false };
-                    }
-                    return { typeName: 'unknown', optional: true, nullable: false };
-                }
-                if (baseType.typeName === 'array') {
-                    // Array access like conditions[0] or length
-                    if (fieldParts[1] === 'length') {
-                        return { typeName: 'number', optional: false, nullable: false };
-                    }
-                    return { typeName: 'object', optional: true, nullable: false };
-                }
-            }
-            return baseType || { typeName: 'unknown', optional: true, nullable: true };
-        }
-        // Status fields are generally optional and may be null during resource creation
-        return { typeName: 'unknown', optional: true, nullable: true };
-    }
-    inferSchemaFieldType(schemaProxy, fieldPath) {
-        if (!schemaProxy) {
-            return { typeName: 'unknown', optional: false, nullable: false };
-        }
-        try {
-            // Extract the field from the schema proxy
-            const parts = fieldPath.split('.');
-            let current = schemaProxy;
-            for (const part of parts) {
-                if (current && typeof current === 'object' && part in current) {
-                    current = current[part];
-                }
-                else {
-                    return { typeName: 'unknown', optional: true, nullable: false };
-                }
-            }
-            // Infer type from the schema field
-            if (current !== undefined) {
-                return this.inferTypeFromValue(current);
-            }
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-        catch (_error) {
-            return { typeName: 'unknown', optional: true, nullable: false };
-        }
-    }
-    inferTypeFromValue(value) {
-        if (value === null) {
-            return { typeName: 'null', optional: false, nullable: true };
-        }
-        if (value === undefined) {
-            return { typeName: 'undefined', optional: true, nullable: false };
-        }
-        const type = typeof value;
-        switch (type) {
-            case 'string':
-                return { typeName: 'string', optional: false, nullable: false };
-            case 'number':
-                return { typeName: 'number', optional: false, nullable: false };
-            case 'boolean':
-                return { typeName: 'boolean', optional: false, nullable: false };
-            case 'object':
-                if (Array.isArray(value)) {
-                    return { typeName: 'array', optional: false, nullable: false };
-                }
-                return { typeName: 'object', optional: false, nullable: false };
-            default:
-                return { typeName: 'unknown', optional: false, nullable: false };
-        }
+        return sourceType.typeName !== targetType.typeName && targetType.typeName !== 'any';
     }
     unifyTypes(type1, type2) {
         if (type1.typeName === type2.typeName)
@@ -802,7 +569,7 @@ export class CelTypeInferenceEngine {
             typeName: `${type1.typeName} | ${type2.typeName}`,
             optional: type1.optional || type2.optional,
             nullable: type1.nullable || type2.nullable,
-            unionTypes: [type1, type2]
+            unionTypes: [type1, type2],
         };
     }
     createEmptyMetadata() {
@@ -812,7 +579,7 @@ export class CelTypeInferenceEngine {
             schemaReferences: [],
             usesOptionalChaining: false,
             canReturnNull: false,
-            complexityScore: 0
+            complexityScore: 0,
         };
     }
     /**