pnpm-catalog-updates 1.0.2 → 1.1.0

package/src/cli/validators/commandValidator.ts

@@ -1,390 +1,375 @@
 /**
  * CLI Command Validation
  *
- * Validates CLI command options and arguments before execution.
- * Provides detailed error messages and suggestions.
+ * QUAL-002: Unified validation logic for CLI commands.
+ * Provides composable validators that can be combined per command.
  */
 
-import { getConfig, type ValidationResult, validateCliOptions } from '@pcu/utils'
+import { existsSync } from 'node:fs'
+import { createValidationResult, t, type ValidationResult } from '@pcu/utils'
+import {
+  FORMAT_CHOICES,
+  isValidAnalysisType,
+  isValidFormat,
+  isValidProvider,
+  isValidSeverity,
+  isValidTarget,
+  SEVERITY_CHOICES,
+  TARGET_CHOICES,
+} from '../constants/cliChoices.js'
 
-export interface ValidatedOptions {
+/**
+ * Validation rule function signature
+ */
+type ValidationRule<T> = (options: T) => { errors: string[]; warnings: string[] }
+
+/**
+ * Base options that many commands share
+ */
+export interface BaseCommandOptions {
   workspace?: string
   catalog?: string
   format?: string
+  verbose?: boolean
+  color?: boolean
+}
+
+/**
+ * Options that include update target
+ */
+export interface TargetOptions {
   target?: string
+}
+
+/**
+ * Options for interactive mode
+ */
+export interface InteractiveOptions {
   interactive?: boolean
   dryRun?: boolean
-  force?: boolean
-  prerelease?: boolean
-  include?: string[]
-  exclude?: string[]
-  createBackup?: boolean
-  verbose?: boolean
-  color?: boolean
-  registry?: string
-  timeout?: number
 }
 
-export class CommandValidator {
-  private config = getConfig().getConfig()
+/**
+ * Options for AI analysis
+ */
+export interface AIOptions {
+  ai?: boolean
+  provider?: string
+  analysisType?: string
+  skipCache?: boolean
+}
 
-  /**
-   * Validate check command options
-   */
-  validateCheckOptions(options: any): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
+/**
+ * Options for security command
+ */
+export interface SecurityOptions {
+  severity?: string
+}
 
-    // Basic validation using utility
-    const basicValidation = validateCliOptions(options)
-    errors.push(...basicValidation.errors)
-    warnings.push(...basicValidation.warnings)
+/**
+ * Graph command specific options
+ */
+export interface GraphOptions {
+  type?: string
+}
 
-    // Check-specific validations
-    if (options.catalog && typeof options.catalog !== 'string') {
-      errors.push('Catalog name must be a string')
-    }
+/**
+ * Create validation result from errors and warnings
+ */
+function toValidationResult(errors: string[], warnings: string[]): ValidationResult {
+  return createValidationResult(errors.length === 0, errors, warnings)
+}
 
-    // Validate mutually exclusive options
-    if (options.interactive && options.format === 'json') {
-      warnings.push('Interactive mode is not useful with JSON output format')
-    }
+/**
+ * Compose multiple validation rules into a single validator
+ */
+export function composeValidators<T>(
+  ...rules: ValidationRule<T>[]
+): (options: T) => ValidationResult {
+  return (options: T) => {
+    const allErrors: string[] = []
+    const allWarnings: string[] = []
 
-    if (options.verbose && options.silent) {
-      errors.push('Cannot use both --verbose and --silent options')
+    for (const rule of rules) {
+      const { errors, warnings } = rule(options)
+      allErrors.push(...errors)
+      allWarnings.push(...warnings)
     }
 
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    }
+    return toValidationResult(allErrors, allWarnings)
   }
+}
 
-  /**
-   * Validate update command options
-   */
-  validateUpdateOptions(options: any): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    // Basic validation
-    const basicValidation = validateCliOptions(options)
-    errors.push(...basicValidation.errors)
-    warnings.push(...basicValidation.warnings)
-
-    // Update-specific validations
-    if (options.interactive && options.dryRun) {
-      errors.push('Cannot use --interactive with --dry-run')
-    }
+// ============================================================================
+// Individual Validation Rules
+// ============================================================================
 
-    if (options.force && !options.dryRun && !options.createBackup) {
-      warnings.push('Using --force without backup. Consider using --create-backup for safety')
-    }
+/**
+ * Validate output format
+ */
+export function validateFormat<T extends { format?: string }>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.format && !isValidFormat(options.format)) {
+    errors.push(t('validation.invalidFormat'))
+  }
 
-    if (options.target === 'major' && !options.force && !options.interactive) {
-      warnings.push(
-        'Major updates may contain breaking changes. Consider using --interactive or --force'
-      )
-    }
+  return { errors, warnings }
+}
 
-    // Validate include/exclude patterns
-    if (options.include && options.exclude) {
-      const overlapping = options.include.some((inc: string) =>
-        options.exclude.some((exc: string) => inc === exc)
-      )
-      if (overlapping) {
-        warnings.push('Some patterns appear in both include and exclude lists')
-      }
-    }
+/**
+ * Validate update target
+ */
+export function validateTarget<T extends TargetOptions>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.target && !isValidTarget(options.target)) {
+    errors.push(t('validation.invalidTarget'))
+  }
 
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    }
+  return { errors, warnings }
+}
+
+/**
+ * Validate workspace path exists
+ */
+export function validateWorkspacePath<T extends { workspace?: string }>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.workspace && !existsSync(options.workspace)) {
+    errors.push(t('validation.workspaceDirNotExist', { path: options.workspace }))
   }
 
-  /**
-   * Validate analyze command arguments
-   */
-  validateAnalyzeArgs(catalog: string, packageName: string, version?: string): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    // Validate catalog name
-    if (!catalog || catalog.trim() === '') {
-      errors.push('Catalog name is required')
-    } else if (catalog.includes('/') || catalog.includes('\\')) {
-      errors.push('Catalog name cannot contain path separators')
-    }
+  return { errors, warnings }
+}
 
-    // Validate package name
-    if (!packageName || packageName.trim() === '') {
-      errors.push('Package name is required')
-    } else {
-      // Basic package name validation
-      const packageNameRegex = /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/
-      if (!packageNameRegex.test(packageName)) {
-        errors.push('Invalid package name format')
-      }
-    }
+/**
+ * Validate interactive mode conflicts
+ */
+export function validateInteractiveConflicts<T extends InteractiveOptions>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.interactive && options.dryRun) {
+    errors.push(t('validation.interactiveWithDryRun'))
+  }
 
-    // Validate version if provided
-    if (version) {
-      const semverRegex =
-        /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
-      if (!semverRegex.test(version)) {
-        errors.push('Invalid version format. Use semantic versioning (e.g., 1.2.3)')
-      }
-    }
+  return { errors, warnings }
+}
 
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    }
+/**
+ * Validate AI provider options
+ */
+export function validateAIOptions<T extends AIOptions>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.provider && !isValidProvider(options.provider)) {
+    errors.push(t('validation.invalidProvider'))
   }
 
-  /**
-   * Validate workspace command options
-   */
-  validateWorkspaceOptions(options: any): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    // Basic validation
-    const basicValidation = validateCliOptions(options)
-    errors.push(...basicValidation.errors)
-    warnings.push(...basicValidation.warnings)
-
-    // Workspace-specific validations
-    const actionCount = [options.validate, options.stats, options.info].filter(Boolean).length
-    if (actionCount > 1) {
-      errors.push('Cannot use multiple workspace actions simultaneously')
-    }
+  if (options.analysisType && !isValidAnalysisType(options.analysisType)) {
+    errors.push(t('validation.invalidAnalysisType'))
+  }
 
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    }
+  return { errors, warnings }
+}
+
+/**
+ * Validate severity level
+ */
+export function validateSeverity<T extends SecurityOptions>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.severity && !isValidSeverity(options.severity)) {
+    errors.push(t('validation.invalidSeverity'))
   }
 
-  /**
-   * Validate global options
-   */
-  validateGlobalOptions(options: any): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    // Validate workspace path
-    if (options.workspace) {
-      // Future: Add path validation logic here
-      // Currently skipped to avoid TypeScript errors
-    }
+  return { errors, warnings }
+}
 
-    // Validate color options
-    if (options.noColor && options.color) {
-      errors.push('Cannot use both --color and --no-color')
-    }
+/**
+ * Validate graph type
+ */
+export function validateGraphType<T extends GraphOptions>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+  const validTypes = ['catalog', 'package', 'full']
+
+  if (options.type && !validTypes.includes(options.type)) {
+    errors.push(t('validation.invalidGraphType', { validTypes: validTypes.join(', ') }))
+  }
 
-    // Check for deprecated options (future-proofing)
-    const deprecatedOptions = ['silent'] // Example
-    for (const deprecated of deprecatedOptions) {
-      if (options[deprecated]) {
-        warnings.push(`Option --${deprecated} is deprecated and will be removed in future versions`)
-      }
-    }
+  return { errors, warnings }
+}
 
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    }
+/**
+ * Validate graph format (subset of formats)
+ */
+export function validateGraphFormat<T extends { format?: string }>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+  const validFormats = ['text', 'mermaid', 'dot', 'json']
+
+  if (options.format && !validFormats.includes(options.format)) {
+    errors.push(t('validation.invalidGraphFormat', { validFormats: validFormats.join(', ') }))
   }
 
-  /**
-   * Validate configuration object
-   */
-  validateConfigFile(configPath: string): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    try {
-      const fs = require('node:fs')
-      // const path = require('path'); // Reserved for future use
-
-      if (!fs.existsSync(configPath)) {
-        errors.push(`Configuration file not found: ${configPath}`)
-        return { isValid: false, errors, warnings }
-      }
-
-      let config: any
-
-      if (configPath.endsWith('.js')) {
-        // JavaScript config file
-        try {
-          delete require.cache[require.resolve(configPath)]
-          config = require(configPath)
-        } catch (error) {
-          errors.push(`Failed to load JavaScript config: ${error}`)
-          return { isValid: false, errors, warnings }
-        }
-      } else {
-        // JSON config file
-        try {
-          const content = fs.readFileSync(configPath, 'utf-8')
-          config = JSON.parse(content)
-        } catch (error) {
-          errors.push(`Failed to parse JSON config: ${error}`)
-          return { isValid: false, errors, warnings }
-        }
-      }
-
-      // Validate config structure
-      if (typeof config !== 'object' || config === null) {
-        errors.push('Configuration must be an object')
-        return { isValid: false, errors, warnings }
-      }
-
-      // Validate known configuration sections
-      if (config.registry && typeof config.registry !== 'object') {
-        errors.push('registry configuration must be an object')
-      }
-
-      if (config.update && typeof config.update !== 'object') {
-        errors.push('update configuration must be an object')
-      }
-
-      if (config.output && typeof config.output !== 'object') {
-        errors.push('output configuration must be an object')
-      }
-
-      // Check for unknown top-level keys
-      const knownKeys = ['registry', 'update', 'output', 'workspace', 'notification', 'logging']
-      const unknownKeys = Object.keys(config).filter((key) => !knownKeys.includes(key))
-
-      if (unknownKeys.length > 0) {
-        warnings.push(`Unknown configuration keys: ${unknownKeys.join(', ')}`)
-      }
-    } catch (error) {
-      errors.push(`Failed to validate configuration file: ${error}`)
-    }
+  return { errors, warnings }
+}
 
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    }
+/**
+ * Options for pattern validation
+ */
+export interface PatternOptions {
+  include?: string[]
+  exclude?: string[]
+}
+
+/**
+ * Validate include/exclude patterns
+ */
+export function validatePatterns<T extends PatternOptions>(
+  options: T
+): {
+  errors: string[]
+  warnings: string[]
+} {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  if (options.include?.some((pattern) => !pattern.trim())) {
+    errors.push(t('validation.includePatternsEmpty'))
   }
 
-  /**
-   * Sanitize and normalize options
-   */
-  sanitizeOptions(options: any): ValidatedOptions {
-    const sanitized: ValidatedOptions = {}
+  if (options.exclude?.some((pattern) => !pattern.trim())) {
+    errors.push(t('validation.excludePatternsEmpty'))
+  }
 
-    // String options
-    if (options.workspace) {
-      sanitized.workspace = String(options.workspace).trim()
-    }
-    if (options.catalog) {
-      sanitized.catalog = String(options.catalog).trim()
-    }
-    if (options.format) {
-      sanitized.format = String(options.format).toLowerCase().trim()
-    }
-    if (options.target) {
-      sanitized.target = String(options.target).toLowerCase().trim()
-    }
-    if (options.registry) {
-      sanitized.registry = String(options.registry).trim()
-    }
+  return { errors, warnings }
+}
 
-    // Boolean options
-    sanitized.interactive = Boolean(options.interactive)
-    sanitized.dryRun = Boolean(options.dryRun)
-    sanitized.force = Boolean(options.force)
-    sanitized.prerelease = Boolean(options.prerelease)
-    sanitized.createBackup = Boolean(options.createBackup)
-    sanitized.verbose = Boolean(options.verbose)
-
-    // Handle color option (tri-state: true, false, or undefined)
-    if (options.color !== undefined) {
-      sanitized.color = Boolean(options.color)
-    } else if (options.noColor) {
-      sanitized.color = false
-    }
+// ============================================================================
+// Pre-composed Validators for Common Command Types
+// ============================================================================
 
-    // Number options
-    if (options.timeout) {
-      const timeout = parseInt(String(options.timeout), 10)
-      if (!Number.isNaN(timeout) && timeout > 0) {
-        sanitized.timeout = timeout
-      }
-    }
+/**
+ * Validator for check command
+ */
+export const validateCheckOptions = composeValidators<
+  BaseCommandOptions & TargetOptions & PatternOptions
+>(validateFormat, validateTarget, validatePatterns)
 
-    // Array options
-    if (options.include) {
-      sanitized.include = Array.isArray(options.include)
-        ? options.include.map((p: any) => String(p).trim()).filter(Boolean)
-        : [String(options.include).trim()].filter(Boolean)
-    }
-    if (options.exclude) {
-      sanitized.exclude = Array.isArray(options.exclude)
-        ? options.exclude.map((p: any) => String(p).trim()).filter(Boolean)
-        : [String(options.exclude).trim()].filter(Boolean)
-    }
+/**
+ * Validator for update command
+ */
+export const validateUpdateOptions = composeValidators<
+  BaseCommandOptions & TargetOptions & InteractiveOptions & AIOptions
+>(validateFormat, validateTarget, validateInteractiveConflicts, validateAIOptions)
 
-    return sanitized
-  }
+/**
+ * Validator for security command
+ */
+export const validateSecurityOptions = composeValidators<BaseCommandOptions & SecurityOptions>(
+  validateFormat,
+  validateSeverity
+)
 
-  /**
-   * Get validation suggestions based on common mistakes
-   */
-  getSuggestions(command: string, options: any): string[] {
-    const suggestions: string[] = []
-
-    switch (command) {
-      case 'check':
-        if (!options.workspace) {
-          suggestions.push('Consider specifying --workspace for non-standard directory structures')
-        }
-        if (options.format === 'json' && options.verbose) {
-          suggestions.push('JSON output already includes detailed info, --verbose may be redundant')
-        }
-        break
-
-      case 'update':
-        if (!options.dryRun && !options.createBackup && !options.force) {
-          suggestions.push('Consider using --dry-run first to preview changes')
-        }
-        if (options.target === 'greatest' && !options.prerelease) {
-          suggestions.push('Add --prerelease to include pre-release versions with greatest target')
-        }
-        break
-
-      case 'analyze':
-        if (!options.format) {
-          suggestions.push('Use --format json for programmatic consumption of analysis data')
-        }
-        break
-
-      case 'workspace':
-        if (!options.validate && !options.stats) {
-          suggestions.push(
-            'Use --validate to check workspace integrity or --stats for detailed information'
-          )
-        }
-        break
-    }
+/**
+ * Validator for graph command
+ */
+export const validateGraphOptions = composeValidators<BaseCommandOptions & GraphOptions>(
+  validateGraphFormat,
+  validateGraphType
+)
 
-    // General suggestions
-    if (this.config.output.verbose && !options.verbose) {
-      suggestions.push('Global verbose mode is enabled in config')
-    }
+/**
+ * Validator for analyze command
+ */
+export const validateAnalyzeOptions = composeValidators<BaseCommandOptions & AIOptions>(
+  validateFormat,
+  validateAIOptions
+)
 
-    return suggestions
-  }
+/**
+ * Validator for init command
+ */
+export const validateInitOptions = composeValidators<BaseCommandOptions>(validateWorkspacePath)
+
+// ============================================================================
+// Legacy Compatibility - Returns string[] for existing command signatures
+// ============================================================================
+
+/**
+ * Wrap validator to return only errors array (legacy compatibility)
+ */
+export function errorsOnly<T>(
+  validator: (options: T) => ValidationResult
+): (options: T) => string[] {
+  return (options: T) => validator(options).errors
+}
+
+/**
+ * Format choices for help text
+ */
+export function formatChoicesHelp(): string {
+  return FORMAT_CHOICES.join(', ')
+}
+
+/**
+ * Target choices for help text
+ */
+export function targetChoicesHelp(): string {
+  return TARGET_CHOICES.join(', ')
+}
+
+/**
+ * Severity choices for help text
+ */
+export function severityChoicesHelp(): string {
+  return SEVERITY_CHOICES.join(', ')
 }