@restnfeel/agentc-starter-kit/src/cms/automation/validators.ts

한국어 기업용 CMS 모듈 - Task Master AI와 함께 빠르게 웹사이트를 구현할 수 있는 재사용 가능한 컴포넌트 시스템

/**
 * Automation validation utilities for ensuring configuration consistency
 * and preventing deployment issues
 */

import { AutomationTask } from "./types.js";

export class AutomationValidator {
  /**
   * Validate automation configuration
   */
  static validateConfiguration(config: Record<string, unknown>): {
    isValid: boolean;
    errors: string[];
    warnings: string[];
  } {
    const errors: string[] = [];
    const warnings: string[] = [];

    // Basic validation
    if (!config.environment) {
      errors.push("Environment must be specified");
    }

    if (!config.version) {
      warnings.push("Version not specified");
    }

    // Environment-specific validations
    if (config.environment === "production") {
      const backupConfig = config.backup as Record<string, unknown> | undefined;
      if (!backupConfig?.enabled) {
        errors.push("Backup must be enabled in production");
      }

      const monitoringConfig = config.monitoring as
        | Record<string, unknown>
        | undefined;
      if (!monitoringConfig?.enabled) {
        warnings.push("Monitoring should be enabled in production");
      }
    }

    return {
      isValid: errors.length === 0,
      errors,
      warnings,
    };
  }

  /**
   * Validate individual automation task
   */
  static validateTask(task: AutomationTask): {
    isValid: boolean;
    errors: string[];
    warnings: string[];
  } {
    const errors: string[] = [];
    const warnings: string[] = [];

    if (!task.id) {
      errors.push("Task ID is required");
    }

    if (!task.name) {
      errors.push("Task name is required");
    }

    if (!task.type) {
      errors.push("Task type is required");
    }

    // Type-specific validations
    switch (task.type) {
      case "validation":
        const rules = task.configuration.rules as unknown[] | undefined;
        if (!rules || rules.length === 0) {
          warnings.push("No validation rules specified");
        }
        break;

      case "deployment":
        if (!task.configuration.target) {
          errors.push("Deployment target is required");
        }
        break;

      case "backup":
        if (!task.configuration.backupLocation) {
          warnings.push("Backup location not specified");
        }
        break;

      case "test":
        if (!task.configuration.testSuite) {
          warnings.push("Test suite not specified");
        }
        break;

      default:
        // No specific validation for other types
        break;
    }

    return {
      isValid: errors.length === 0,
      errors,
      warnings,
    };
  }

  /**
   * Validate environment-specific settings
   */
  static validateEnvironmentSettings(
    config: Record<string, unknown>,
    environment: string
  ): string[] {
    const issues: string[] = [];

    switch (environment) {
      case "production":
        const sslConfig = config.ssl as Record<string, unknown> | undefined;
        if (!sslConfig?.enabled) {
          issues.push("SSL must be enabled in production");
        }

        const loggingConfig = config.logging as
          | Record<string, unknown>
          | undefined;
        if (!loggingConfig?.level || loggingConfig.level === "debug") {
          issues.push("Debug logging should not be enabled in production");
        }
        break;

      case "development":
        const cacheConfig = config.cache as Record<string, unknown> | undefined;
        if (cacheConfig?.enabled) {
          issues.push(
            "Caching can be disabled in development for easier debugging"
          );
        }
        break;

      default:
        // No specific validation for other environments
        break;
    }

    return issues;
  }
}

export class ConfigurationSchemaValidator {
  private static schemas: Map<string, Record<string, unknown>> = new Map();

  /**
   * Register a configuration schema
   */
  static registerSchema(name: string, schema: Record<string, unknown>): void {
    this.schemas.set(name, schema);
  }

  /**
   * Validate configuration against registered schema
   */
  static validate(
    configName: string,
    config: Record<string, unknown>
  ): {
    isValid: boolean;
    errors: string[];
  } {
    const schema = this.schemas.get(configName);
    if (!schema) {
      return {
        isValid: false,
        errors: [`Schema not found for configuration: ${configName}`],
      };
    }

    const errors: string[] = [];

    // Basic schema validation (simplified)
    for (const [key, schemaValue] of Object.entries(schema)) {
      if (schemaValue === "required" && !config[key]) {
        errors.push(`Required field missing: ${key}`);
      }
    }

    return {
      isValid: errors.length === 0,
      errors,
    };
  }

  /**
   * Initialize default schemas
   */
  static initializeDefaultSchemas(): void {
    // CMS Configuration Schema
    this.registerSchema("cms", {
      version: "required",
      environment: "required",
      database: "required",
      cache: "optional",
      logging: "required",
      ssl: "optional",
      backup: "optional",
      monitoring: "optional",
    });

    // Component Configuration Schema
    this.registerSchema("component", {
      name: "required",
      version: "required",
      dependencies: "optional",
      props: "optional",
      theme: "optional",
    });

    // Deployment Configuration Schema
    this.registerSchema("deployment", {
      target: "required",
      strategy: "required",
      rollback: "required",
      healthChecks: "required",
      timeout: "optional",
    });
  }
}

// Initialize default schemas
ConfigurationSchemaValidator.initializeDefaultSchemas();