reliant-type 1.0.0

package/src/core/schema/optimization/ObjectValidationCache.ts

@@ -0,0 +1,560 @@
+/**
+ * Production Object Validation Cache System
+ *
+ * High-performance caching for object validation with intelligent
+ * hot-path optimization and memory management.
+ */
+
+import { SchemaValidationResult, ValidationError } from "../../types/types";
+import type {
+  CachedValidation,
+  ValidationPath,
+} from "../../types/objValidationCache";
+import { ErrorHandler } from "../mode/interfaces/errors/ErrorHandler";
+// Fast hash function for objects
+function djb2Hash(str: string): string {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+// Optimized object key extractor
+function getObjectKeys(obj: any): string {
+  if (typeof obj !== "object" || obj === null) return typeof obj;
+
+  const keys = [];
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) keys.push(key);
+  }
+  return keys.sort().join(",");
+}
+
+export class ObjectValidationCache {
+  private static cache = new Map<string, CachedValidation>();
+  private static pathCache = new Map<string, ValidationPath>();
+  private static structureCache = new Map<
+    string,
+    (value: any) => SchemaValidationResult
+  >();
+  private static hotPaths = new Set<string>();
+
+  private static readonly MAX_CACHE_SIZE = 5000;
+  private static readonly HOT_PATH_THRESHOLD = 10;
+  private static readonly CACHE_TTL = 300000; // 5 minutes
+
+  private static stats = {
+    hits: 0,
+    misses: 0,
+    hotPathHits: 0,
+    structureHits: 0,
+    evictions: 0,
+  };
+
+  /**
+   * Get cached validation result or compute and cache new one
+   */
+  static getCachedValidation(
+    value: any,
+    validator: (value: any) => SchemaValidationResult,
+    path: string[] = []
+  ): SchemaValidationResult {
+    const cacheKey = this.generateCacheKey(value, path);
+    const structureHash = this.generateStructureHash(value);
+
+    // Check cache
+    const cached = this.cache.get(cacheKey);
+    if (cached && this.isCacheValid(cached)) {
+      cached.accessCount++;
+      cached.lastAccessed = Date.now();
+      this.stats.hits++;
+
+      // Mark as hot path if accessed frequently
+      if (cached.accessCount >= this.HOT_PATH_THRESHOLD) {
+        this.markAsHotPath(path);
+        this.stats.hotPathHits++;
+      }
+
+      return cached.result;
+    }
+
+    this.stats.misses++;
+
+    // Compute validation
+    const startTime = Date.now();
+    const result = validator(value);
+    const validationTime = Date.now() - startTime;
+
+    // Cache the result
+    const cacheEntry: CachedValidation = {
+      result,
+      structureHash,
+      accessCount: 1,
+      lastAccessed: Date.now(),
+      validationTime,
+    };
+
+    this.cache.set(cacheKey, cacheEntry);
+    this.updatePathStatistics(path, validationTime);
+    this.cleanupCache();
+
+    return result;
+  }
+
+  /**
+   * Optimized validation for nested objects
+   */
+  static validateNestedObject(
+    value: any,
+    schema: Record<string, any>,
+    path: string[] = []
+  ): SchemaValidationResult {
+    if (typeof value !== "object" || value === null) {
+      return {
+        success: false,
+        errors: [ErrorHandler.createTypeError([], "object", value)],
+        warnings: [],
+        data: value,
+      };
+    }
+
+    // Check if this is a hot path
+    const pathKey = path.join(".");
+    if (this.hotPaths.has(pathKey)) {
+      return this.validateHotPath(value, schema, path);
+    }
+
+    // Standard nested validation with caching
+    return this.validateWithStructuralCaching(value, schema, path);
+  }
+
+  /**
+   * Optimized validation for frequently accessed paths
+   */
+  private static validateHotPath(
+    value: any,
+    schema: Record<string, any>,
+    path: string[]
+  ): SchemaValidationResult {
+    const pathKey = path.join(".");
+    const cachedPath = this.pathCache.get(pathKey);
+
+    if (cachedPath) {
+      return cachedPath.validator(value);
+    }
+
+    // Compile optimized validator for this hot path
+    const optimizedValidator = this.compileHotPathValidator(schema);
+
+    this.pathCache.set(pathKey, {
+      path,
+      validator: optimizedValidator,
+      isHotPath: true,
+      avgValidationTime: 0,
+    });
+
+    return optimizedValidator(value);
+  }
+
+  /**
+   * Validation with structural caching
+   */
+  private static validateWithStructuralCaching(
+    value: any,
+    schema: Record<string, any>,
+    path: string[]
+  ): SchemaValidationResult {
+    const structureKey = this.generateStructureKey(schema);
+
+    // Check if we have a cached structure validator
+    let structureValidator = this.structureCache.get(structureKey);
+    if (!structureValidator) {
+      structureValidator = this.compileStructureValidator(schema);
+      this.structureCache.set(structureKey, structureValidator);
+      this.stats.structureHits++;
+    }
+
+    return structureValidator(value);
+  }
+
+  /**
+   * Compile optimized validator for hot paths
+   */
+  private static compileHotPathValidator(
+    schema: Record<string, any>
+  ): (value: any) => SchemaValidationResult {
+    // Pre-compile field validators for maximum performance
+    const validationChecks: Array<
+      (value: any, errors: ValidationError[], data: any) => void
+    > = [];
+
+    for (const [key, fieldType] of Object.entries(schema)) {
+      const isOptional = this.isOptional(fieldType);
+      const cleanType = isOptional ? fieldType.slice(0, -1) : fieldType;
+
+      // Create optimized validation function for this field
+      const fieldValidator = this.createFieldValidator(
+        key,
+        cleanType,
+        isOptional
+      );
+      validationChecks.push(fieldValidator);
+    }
+
+    // Return highly optimized validator
+    return (value: any): SchemaValidationResult => {
+      const errors: ValidationError[] = [];
+      const validatedData: any = {};
+
+      // Execute all field validations in a tight loop
+      for (let i = 0; i < validationChecks.length; i++) {
+        validationChecks[i](value, errors, validatedData);
+      }
+
+      return {
+        success: errors.length === 0,
+        errors,
+        warnings: [],
+        data: validatedData,
+      };
+    };
+  }
+
+  /**
+   * Create optimized field validator
+   */
+  private static createFieldValidator(
+    key: string,
+    fieldType: string,
+    isOptional: boolean
+  ): (value: any, errors: ValidationError[], data: any) => void {
+    // Pre-compile type checking logic
+    if (fieldType === "string") {
+      return (value: any, errors: ValidationError[], data: any) => {
+        const fieldValue = value[key];
+        if (fieldValue === undefined) {
+          if (!isOptional)
+            errors.push(ErrorHandler.createMissingFieldError([], key));
+        } else if (typeof fieldValue !== "string") {
+          errors.push(ErrorHandler.createTypeError([], "string", fieldValue));
+        } else {
+          data[key] = fieldValue;
+        }
+      };
+    }
+
+    if (fieldType === "number") {
+      return (value: any, errors: ValidationError[], data: any) => {
+        const fieldValue = value[key];
+        if (fieldValue === undefined) {
+          if (!isOptional)
+            errors.push(ErrorHandler.createMissingFieldError([], key));
+        } else if (typeof fieldValue !== "number" || isNaN(fieldValue)) {
+          errors.push(ErrorHandler.createTypeError([], "number", fieldValue));
+        } else {
+          data[key] = fieldValue;
+        }
+      };
+    }
+
+    if (fieldType === "boolean") {
+      return (value: any, errors: ValidationError[], data: any) => {
+        const fieldValue = value[key];
+        if (fieldValue === undefined) {
+          if (!isOptional)
+            errors.push(ErrorHandler.createMissingFieldError([], key));
+        } else if (typeof fieldValue !== "boolean") {
+          errors.push(ErrorHandler.createTypeError([], "boolean", fieldValue));
+        } else {
+          data[key] = fieldValue;
+        }
+      };
+    }
+
+    if (fieldType.includes("|")) {
+      const allowedValues = new Set(fieldType.split("|").map((v) => v.trim()));
+      return (value: any, errors: ValidationError[], data: any) => {
+        const fieldValue = value[key];
+        if (fieldValue === undefined) {
+          if (!isOptional)
+            errors.push(ErrorHandler.createMissingFieldError([], key));
+        } else if (!allowedValues.has(String(fieldValue))) {
+          errors.push(
+            ErrorHandler.createUnionError(
+              [],
+              Array.from(allowedValues),
+              fieldValue
+            )
+          );
+        } else {
+          data[key] = fieldValue;
+        }
+      };
+    }
+
+    // Array type
+    if (fieldType.endsWith("[]")) {
+      const itemType = fieldType.slice(0, -2);
+      return (value: any, errors: ValidationError[], data: any) => {
+        const fieldValue = value[key];
+        if (fieldValue === undefined) {
+          if (!isOptional)
+            errors.push(ErrorHandler.createMissingFieldError([], key));
+        } else if (!Array.isArray(fieldValue)) {
+          errors.push(ErrorHandler.createTypeError([], "array", fieldValue));
+        } else {
+          data[key] = fieldValue;
+        }
+      };
+    }
+
+    // Default validator
+    return (value: any, errors: ValidationError[], data: any) => {
+      const fieldValue = value[key];
+      if (fieldValue === undefined && !isOptional) {
+        errors.push(ErrorHandler.createMissingFieldError([], key));
+      } else if (fieldValue !== undefined) {
+        data[key] = fieldValue;
+      }
+    };
+  }
+
+  /**
+   * Compile structure validator
+   */
+  private static compileStructureValidator(
+    schema: Record<string, any>
+  ): (value: any) => SchemaValidationResult {
+    const schemaKeys = Object.keys(schema);
+    const requiredFields = schemaKeys.filter(
+      (key) => !this.isOptional(schema[key])
+    );
+
+    return (value: any): SchemaValidationResult => {
+      const errors: ValidationError[] = [];
+      const validatedData: any = {};
+
+      // Check required fields first
+      for (let i = 0; i < requiredFields.length; i++) {
+        const key = requiredFields[i];
+        if (value[key] === undefined) {
+          errors.push(ErrorHandler.createMissingFieldError([], key));
+        }
+      }
+
+      // Process all fields
+      for (let i = 0; i < schemaKeys.length; i++) {
+        const key = schemaKeys[i];
+        const fieldValue = value[key];
+
+        if (fieldValue !== undefined) {
+          validatedData[key] = fieldValue;
+        }
+      }
+
+      return {
+        success: errors.length === 0,
+        errors,
+        warnings: [],
+        data: validatedData,
+      };
+    };
+  }
+
+  /**
+   * Check if field type is optional
+   */
+  private static isOptional(fieldType: any): boolean {
+    return typeof fieldType === "string" && fieldType.endsWith("?");
+  }
+
+  /**
+   * Mark path as hot path for optimization
+   */
+  private static markAsHotPath(path: string[]): void {
+    const pathKey = path.join(".");
+    this.hotPaths.add(pathKey);
+  }
+
+  /**
+   * Update path statistics
+   */
+  private static updatePathStatistics(
+    path: string[],
+    validationTime: number
+  ): void {
+    const pathKey = path.join(".");
+    const existing = this.pathCache.get(pathKey);
+
+    if (existing) {
+      existing.avgValidationTime =
+        (existing.avgValidationTime + validationTime) / 2;
+    } else {
+      this.pathCache.set(pathKey, {
+        path,
+        validator: () => ({
+          success: true,
+          errors: [],
+          warnings: [],
+          data: null,
+        }),
+        isHotPath: false,
+        avgValidationTime: validationTime,
+      });
+    }
+  }
+
+  /**
+   * Generate cache key for value and path
+   */
+  private static generateCacheKey(value: any, path: string[]): string {
+    const valueHash = this.hashValue(value);
+    const pathHash = path.join(".");
+    return `${pathHash}:${valueHash}`;
+  }
+
+  /**
+   * Generate structure hash for value
+   */
+  private static generateStructureHash(value: any): string {
+    return getObjectKeys(value);
+  }
+
+  /**
+   * Generate structure key for schema
+   */
+  private static generateStructureKey(schema: Record<string, any>): string {
+    const keys = Object.keys(schema).sort();
+    const typeSignature = keys.map((k) => `${k}:${schema[k]}`).join(";");
+    return djb2Hash(typeSignature);
+  }
+
+  /**
+   * Fast hash function for values
+   */
+  private static hashValue(value: any): string {
+    if (typeof value !== "object" || value === null) {
+      return String(value);
+    }
+
+    // Fast hash for objects
+    const str = JSON.stringify(value);
+    return djb2Hash(
+      str.length > 100 ? str.substring(0, 100 + (str.length % 50)) : str
+    );
+  }
+
+  /**
+   * Check if cache entry is still valid
+   */
+  private static isCacheValid(cached: CachedValidation): boolean {
+    return Date.now() - cached.lastAccessed < this.CACHE_TTL;
+  }
+
+  /**
+   * Cleanup old cache entries using LRU strategy
+   */
+  private static cleanupCache(): void {
+    if (this.cache.size <= this.MAX_CACHE_SIZE) return;
+
+    const now = Date.now();
+    const entries: [string, CachedValidation][] = [];
+
+    // Collect entries with scores
+    for (const [key, cached] of this.cache) {
+      const age = now - cached.lastAccessed;
+      const score = cached.accessCount / (age + 1); // Higher score = more valuable
+      entries.push([key, cached]);
+    }
+
+    // Sort by value (lower score = less valuable)
+    entries.sort((a, b) => {
+      const ageA = now - a[1].lastAccessed;
+      const ageB = now - b[1].lastAccessed;
+      const scoreA = a[1].accessCount / (ageA + 1);
+      const scoreB = b[1].accessCount / (ageB + 1);
+      return scoreA - scoreB;
+    });
+
+    // Remove least valuable entries
+    const toRemove =
+      this.cache.size -
+      this.MAX_CACHE_SIZE +
+      Math.floor(this.MAX_CACHE_SIZE * 0.1);
+    for (let i = 0; i < toRemove && i < entries.length; i++) {
+      this.cache.delete(entries[i][0]);
+      this.stats.evictions++;
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  static getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    const hitRate = total > 0 ? this.stats.hits / total : 0;
+
+    return {
+      ...this.stats,
+      hitRate,
+      cacheSize: this.cache.size,
+      pathCacheSize: this.pathCache.size,
+      structureCacheSize: this.structureCache.size,
+      hotPathCount: this.hotPaths.size,
+    };
+  }
+
+  /**
+   * Clear all caches
+   */
+  static clearCache(): void {
+    this.cache.clear();
+    this.pathCache.clear();
+    this.structureCache.clear();
+    this.hotPaths.clear();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      hotPathHits: 0,
+      structureHits: 0,
+      evictions: 0,
+    };
+  }
+
+  /**
+   * Warm up cache with common validation patterns
+   */
+  static warmup(commonSchemas: Record<string, any>[], sampleData: any[]): void {
+    for (const schema of commonSchemas) {
+      for (const data of sampleData) {
+        this.validateNestedObject(data, schema);
+      }
+    }
+  }
+
+  /**
+   * Get cache efficiency metrics
+   */
+  static getEfficiencyMetrics() {
+    const stats = this.getStats();
+    return {
+      hitRate: stats.hitRate,
+      hotPathEfficiency: stats.hotPathHits / (stats.hits || 1),
+      memoryUtilization: stats.cacheSize / this.MAX_CACHE_SIZE,
+      avgValidationTime: this.calculateAvgValidationTime(),
+    };
+  }
+
+  private static calculateAvgValidationTime(): number {
+    let totalTime = 0;
+    let count = 0;
+
+    for (const cached of this.cache.values()) {
+      totalTime += cached.validationTime;
+      count++;
+    }
+
+    return count > 0 ? totalTime / count : 0;
+  }
+}