reliant-type 1.0.0

package/src/core/schema/mode/interfaces/validators/EnhancedErrorReporting.ts

@@ -0,0 +1,227 @@
+/**
+ * Enhanced Error Reporting System
+ * 
+ * This enhancement provides more detailed error messages for complex conditional validations
+ */
+
+export interface ConditionalValidationError {
+  field: string;
+  expected: string;
+  received: any;
+  receivedType: string;
+  condition: string;
+  conditionMet: boolean;
+  runtimePropertyExists: boolean;
+  runtimePropertyPath: string;
+  suggestion: string;
+}
+
+export class EnhancedSchemaValidator {
+  
+  static generateDetailedError(
+    field: string,
+    conditionalRule: string,
+    input: any,
+    runtimeData: any
+  ): ConditionalValidationError {
+    
+    // Parse the conditional rule
+    const ruleMatch = conditionalRule.match(/when\s+(.+?)\.\$exists\(\)\s+\*\?\s+(\w+(?:\[\])?)\s+:\s+=(.+)/);
+    
+    if (!ruleMatch) {
+      throw new Error(`Invalid conditional rule format: ${conditionalRule}`);
+    }
+    
+    const [, runtimePath, expectedType, defaultValue] = ruleMatch;
+    const receivedValue = input[field];
+    const runtimeExists = this.checkRuntimePath(runtimeData, runtimePath);
+    
+    return {
+      field,
+      expected: expectedType,
+      received: receivedValue,
+      receivedType: typeof receivedValue,
+      condition: `${runtimePath}.$exists()`,
+      conditionMet: runtimeExists,
+      runtimePropertyExists: runtimeExists,
+      runtimePropertyPath: runtimePath,
+      suggestion: this.generateSuggestion(field, expectedType, receivedValue, runtimeExists, defaultValue)
+    };
+  }
+  
+  private static checkRuntimePath(obj: any, path: string): boolean {
+    const parts = path.split('.');
+    let current = obj;
+    
+    for (const part of parts) {
+      if (current == null || typeof current !== 'object' || !(part in current)) {
+        return false;
+      }
+      current = current[part];
+    }
+    
+    return current !== undefined && current !== null;
+  }
+  
+  private static generateSuggestion(
+    field: string,
+    expectedType: string,
+    receivedValue: any,
+    runtimeExists: boolean,
+    defaultValue: string
+  ): string {
+    if (!runtimeExists) {
+      return `Since the runtime condition is not met, this field will use the default value: ${defaultValue}. You can omit this field from your input.`;
+    }
+    
+    if (typeof receivedValue !== expectedType.replace('[]', '')) {
+      return `Convert '${receivedValue}' to ${expectedType}. Expected: ${this.getTypeExample(expectedType)}`;
+    }
+    
+    return "Value is valid";
+  }
+  
+  private static getTypeExample(type: string): string {
+    const examples: Record<string, string> = {
+      'boolean': 'true or false',
+      'string': '"example string"',
+      'number': '42 or 3.14',
+      'int': '42',
+      'object': '{ key: "value" }',
+      'array': '["item1", "item2"]',
+      'string[]': '["item1", "item2"]',
+      'number[]': '[1, 2, 3]',
+      'boolean[]': '[true, false]'
+    };
+    
+    return examples[type] || `a ${type}`;
+  }
+  
+  static formatDetailedError(error: ConditionalValidationError): string {
+    const { field, expected, received, receivedType, condition, conditionMet, suggestion } = error;
+    
+    return [
+      `❌ Validation Error for field '${field}':`,
+      `   Expected: ${expected}`,
+      `   Received: ${JSON.stringify(received)} (${receivedType})`,
+      `   Conditional Rule: when ${condition} → validate as ${expected}`,
+      `   Runtime Condition Met: ${conditionMet ? '✅' : '❌'}`,
+      `   💡 Suggestion: ${suggestion}`,
+      ``
+    ].join('\n');
+  }
+}
+
+// Example usage in your test framework
+export class TestResultAnalyzer {
+  
+  static analyzeConditionalValidation(
+    testCase: any,
+    validationResult: any,
+    schema: any
+  ): void {
+    console.log(`\n🔍 DETAILED CONDITIONAL ANALYSIS for ${testCase.name}:`);
+    
+    // Extract conditional fields from schema definition
+    const conditionalFields = this.extractConditionalFieldsFromSchema(schema);
+    
+    conditionalFields.forEach(fieldInfo => {
+      const { fieldName, rule } = fieldInfo;
+      const inputValue = testCase.input[fieldName];
+      const outputValue = validationResult.data?.[fieldName];
+      const runtimeExists = this.checkRuntimeCondition(fieldInfo.runtimePath, testCase.input);
+      
+      console.log(`\n  📊 Field: ${fieldName}`);
+      console.log(`     Rule: ${rule}`);
+      console.log(`     Runtime Condition (${fieldInfo.runtimePath}): ${runtimeExists ? '✅ EXISTS' : '❌ MISSING'}`);
+      
+      if (runtimeExists) {
+        // Should validate user input
+        const typeValid = typeof inputValue === fieldInfo.expectedType;
+        console.log(`     Input Validation: ${typeValid ? '✅' : '❌'} (${typeof inputValue} vs ${fieldInfo.expectedType})`);
+        console.log(`     Value: ${JSON.stringify(inputValue)} → ${JSON.stringify(outputValue)}`);
+        console.log(`     Preserved: ${inputValue === outputValue ? '✅' : '❌'}`);
+      } else {
+        // Should use default
+        const usedDefault = outputValue === fieldInfo.defaultValue;
+        console.log(`     Default Applied: ${usedDefault ? '✅' : '❌'}`);
+        console.log(`     Expected Default: ${JSON.stringify(fieldInfo.defaultValue)}`);
+        console.log(`     Actual Output: ${JSON.stringify(outputValue)}`);
+        console.log(`     User Input Ignored: ${inputValue !== outputValue ? '✅' : '❌'}`);
+      }
+    });
+  }
+  
+  private static extractConditionalFieldsFromSchema(schema: any): Array<{
+    fieldName: string;
+    rule: string;
+    runtimePath: string;
+    expectedType: string;
+    defaultValue: any;
+  }> {
+    // This would parse your schema definition to extract conditional field info
+    // Implementation depends on your schema structure
+    return [];
+  }
+  
+  private static checkRuntimeCondition(path: string, input: any): boolean {
+    const parts = path.split('.');
+    let current = input;
+    
+    for (const part of parts) {
+      if (current == null || typeof current !== 'object' || !(part in current)) {
+        return false;
+      }
+      current = current[part];
+    }
+    
+    return current !== undefined && current !== null;
+  }
+}
+
+// Performance monitoring enhancement
+export class PerformanceProfiler {
+  
+  static profileConditionalValidation(testCase: any, schema: any): {
+    totalTime: number;
+    conditionCheckTime: number;
+    validationTime: number;
+    breakdown: Array<{ field: string; time: number; }>;
+  } {
+    const start = performance.now();
+    
+    // Simulate detailed timing
+    const conditionStart = performance.now();
+    // ... condition checking logic
+    const conditionEnd = performance.now();
+    
+    const validationStart = performance.now();
+    const result = schema.safeParse(testCase.input);
+    const validationEnd = performance.now();
+    
+    const end = performance.now();
+    
+    return {
+      totalTime: end - start,
+      conditionCheckTime: conditionEnd - conditionStart,
+      validationTime: validationEnd - validationStart,
+      breakdown: [] // Field-by-field timing
+    };
+  }
+  
+  static reportPerformanceBottlenecks(profiles: any[]): void {
+    console.log('\n⚡ PERFORMANCE ANALYSIS:');
+    
+    const avgTime = profiles.reduce((sum, p) => sum + p.totalTime, 0) / profiles.length;
+    const slowest = profiles.reduce((max, p) => p.totalTime > max.totalTime ? p : max);
+    
+    console.log(`   Average Execution Time: ${avgTime.toFixed(2)}ms`);
+    console.log(`   Slowest Test: ${slowest.totalTime.toFixed(2)}ms`);
+    
+    if (avgTime > 5) {
+      console.log('   ⚠️  Consider optimizing for better performance');
+    } else if (avgTime < 1) {
+      console.log('   🚀 Excellent performance!');
+    }
+  }
+}

package/src/core/schema/mode/interfaces/validators/TypeGuards.ts

@@ -0,0 +1,288 @@
+/**
+ * Type Guards Module
+ * 
+ * Contains all type guard functions extracted from InterfaceSchema
+ * to improve maintainability and reduce file size.
+ */
+
+import {
+  ConstantValue,
+  OptionalConstantValue,
+  SchemaInterface,
+  OptionalSchemaInterface,
+  UnionValue,
+} from "../../../../types/SchemaValidator.type";
+ 
+/**
+ * Type guard functions for schema validation
+ */
+export class TypeGuards {
+  /**
+   * Check if value is a union value
+   */
+  static isUnionValue(value: any): value is UnionValue {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      "union" in value &&
+      Array.isArray(value.union)
+    );
+  }
+
+  /**
+   * Check if value is a constant value
+   */
+  static isConstantValue(value: any): value is ConstantValue | OptionalConstantValue {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      "const" in value
+    );
+  }
+
+  /**
+   * Check if value is an optional schema interface
+   */
+  static isOptionalSchemaInterface(value: any): value is OptionalSchemaInterface {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      "optional" in value &&
+      value.optional === true &&
+      "schema" in value
+    );
+  }
+
+  /**
+   * Check if value is a conditional validation object
+   */
+  static isConditionalValidation(value: any): boolean {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      value.__conditional === true &&
+      "fieldName" in value &&
+      "conditions" in value
+    );
+  }
+
+  /**
+   * Check if value is a schema interface
+   */
+  static isSchemaInterface(value: any): value is SchemaInterface {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      !TypeGuards.isConstantValue(value) &&
+      !TypeGuards.isOptionalSchemaInterface(value) &&
+      !TypeGuards.isConditionalValidation(value)
+    );
+  }
+
+  /**
+   * Check if value is an array schema (single element array)
+   */
+  static isArraySchema(value: any): boolean {
+    return Array.isArray(value) && value.length === 1;
+  }
+
+  /**
+   * Check if field type is a string-based type
+   */
+  static isStringFieldType(fieldType: any): fieldType is string {
+    return typeof fieldType === "string";
+  }
+
+  /**
+   * Check if string contains union syntax
+   */
+  static isUnionType(fieldType: string): boolean {
+    return fieldType.includes("|");
+  }
+
+  /**
+   * Check if string is a constant type (starts with =)
+   */
+  static isConstantType(fieldType: string): boolean {
+    return fieldType.startsWith("=");
+  }
+
+  /**
+   * Check if string is an array type (ends with [])
+   */
+  static isArrayType(fieldType: string): boolean {
+    // Remove optional marker first
+    const type = fieldType.endsWith("?") ? fieldType.slice(0, -1) : fieldType;
+    // Remove constraints if present
+    const baseType = type.match(/^([a-zA-Z\[\]]+)/)?.[1] || type;
+    return baseType.endsWith("[]");
+  }
+
+  /**
+   * Check if string is an optional type (ends with ?)
+   */
+  static isOptionalType(fieldType: string): boolean {
+    return fieldType.endsWith("?");
+  }
+
+  /**
+   * Check if string is a record type
+   */
+  static isRecordType(fieldType: string): boolean {
+    return fieldType.startsWith("record<") && fieldType.endsWith(">");
+  }
+
+  /**
+   * Check if string has constraints (contains parentheses)
+   */
+  static hasConstraints(fieldType: string): boolean {
+    // Remove optional marker
+    const type = fieldType.endsWith("?") ? fieldType.slice(0, -1) : fieldType;
+    return /^[a-zA-Z\[\]]+\([^)]*\)$/.test(type);
+  }
+
+  /**
+   * Check if value is a primitive type
+   */
+  static isPrimitive(value: any): boolean {
+    return (
+      value === null ||
+      value === undefined ||
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean" ||
+      typeof value === "symbol" ||
+      typeof value === "bigint"
+    );
+  }
+
+  /**
+   * Check if value is a valid email format
+   */
+  static isValidEmail(value: string): boolean {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+  }
+
+  /**
+   * Check if value is a valid URL format
+   */
+  static isValidUrl(value: string): boolean {
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if value is a valid UUID format
+   */
+  static isValidUuid(value: string): boolean {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+  }
+
+  /**
+   * Check if value is a valid phone format
+   */
+  static isValidPhone(value: string): boolean {
+    const cleanPhone = value.replace(/[\s\-\(\)\.+]/g, "");
+    return /^[1-9]\d{6,14}$/.test(cleanPhone);
+  }
+
+  /**
+   * Check if value is a valid slug format
+   */
+  static isValidSlug(value: string): boolean {
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+  }
+
+  /**
+   * Check if value is a valid username format
+   */
+  static isValidUsername(value: string): boolean {
+    return /^[a-zA-Z0-9_-]{3,20}$/.test(value);
+  }
+
+  /**
+   * Check if value is empty (for empty/!empty operators)
+   */
+  static isEmpty(value: any): boolean {
+    if (value === null || value === undefined) return true;
+    if (typeof value === "string") return value.length === 0;
+    if (Array.isArray(value)) return value.length === 0;
+    if (typeof value === "object") return Object.keys(value).length === 0;
+    return false;
+  }
+
+  /**
+   * Check if value is a valid JSON string
+   */
+  static isValidJson(value: string): boolean {
+    try {
+      JSON.parse(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if value is a valid date
+   */
+  static isValidDate(value: any): boolean {
+    if (value instanceof Date) {
+      return !isNaN(value.getTime());
+    }
+    if (typeof value === "string" || typeof value === "number") {
+      const date = new Date(value);
+      return !isNaN(date.getTime());
+    }
+    return false;
+  }
+
+  /**
+   * Check if value is a finite number
+   */
+  static isFiniteNumber(value: any): boolean {
+    return typeof value === "number" && isFinite(value);
+  }
+
+  /**
+   * Check if value is an integer
+   */
+  static isInteger(value: any): boolean {
+    return typeof value === "number" && isFinite(value) && value % 1 === 0;
+  }
+
+  /**
+   * Check if value is a positive number
+   */
+  static isPositive(value: any): boolean {
+    return typeof value === "number" && isFinite(value) && value > 0;
+  }
+
+  /**
+   * Check if value is a negative number
+   */
+  static isNegative(value: any): boolean {
+    return typeof value === "number" && isFinite(value) && value < 0;
+  }
+
+  /**
+   * Get the type name of a value for error messages
+   */
+  static getTypeName(value: any): string {
+    if (value === null) return "null";
+    if (value === undefined) return "undefined";
+    if (Array.isArray(value)) return "array";
+    if (value instanceof Date) return "Date";
+    if (value instanceof RegExp) return "RegExp";
+    return typeof value;
+  }
+}