@dawans/promptshield/dist/application/commands/validate/ValidateCommandHandler.js

Secure your LLM stack with enterprise-grade RulePacks for AI safety scanning

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidateCommandHandler = void 0;
const Result_1 = require("../../../shared/types/Result");
const ValidationOptions_1 = require("../../../domains/validation/core/entities/ValidationOptions");
/**
 * Validate command handler
 */
class ValidateCommandHandler {
    constructor(validationEngine, logger) {
        this.validationEngine = validationEngine;
        this.logger = logger;
    }
    async execute(command) {
        try {
            this.logger.info('Starting validation', { target: command.target });
            // Convert command options to validation options
            const validationOptions = this.buildValidationOptions(command.options);
            // Perform validation
            const result = await this.validationEngine.validate(command.target, validationOptions);
            if (result.isErr()) {
                this.logger.error('Validation failed', result.error);
                return result;
            }
            const validationResult = result.value;
            // Log results
            this.logValidationResult(validationResult, command.options);
            // Display results
            this.displayValidationResult(validationResult, command.options);
            return (0, Result_1.ok)(validationResult);
        }
        catch (error) {
            this.logger.error('Validation execution failed', error);
            return (0, Result_1.err)(new Error(`Validation execution failed: ${error}`));
        }
    }
    buildValidationOptions(cmdOptions) {
        const builder = new ValidationOptions_1.ValidationOptionsBuilder();
        if (cmdOptions.strict !== undefined) {
            builder.strict(cmdOptions.strict);
        }
        if (cmdOptions.verbose !== undefined) {
            builder.verbose(cmdOptions.verbose);
        }
        if (cmdOptions.skipWarnings !== undefined) {
            builder.skipWarnings(cmdOptions.skipWarnings);
        }
        if (cmdOptions.maxErrors !== undefined) {
            builder.maxErrors(cmdOptions.maxErrors);
        }
        if (cmdOptions.format !== undefined) {
            builder.format(cmdOptions.format);
        }
        return builder.build();
    }
    logValidationResult(result, options) {
        const { target, isValid, errors, warnings } = result;
        if (isValid) {
            this.logger.info('Validation completed successfully', {
                target,
                warnings: warnings.length,
                verbose: options.verbose,
            });
        }
        else {
            this.logger.error('Validation failed', new Error(`Validation failed for ${target}`), {
                target,
                errors: errors.length,
                warnings: warnings.length,
                verbose: options.verbose,
            });
        }
    }
    displayValidationResult(result, options) {
        const outputFormat = options.output || 'table';
        switch (outputFormat) {
            case 'json':
                this.displayJsonResult(result);
                break;
            case 'summary':
                this.displaySummaryResult(result);
                break;
            case 'table':
            default:
                this.displayTableResult(result, options);
                break;
        }
    }
    displayJsonResult(result) {
        console.log(JSON.stringify(result, null, 2));
    }
    displaySummaryResult(result) {
        const { target, isValid, errors, warnings, validationType } = result;
        console.log(`\n📋 Validation Summary for ${target}`);
        console.log(`Type: ${validationType}`);
        console.log(`Status: ${isValid ? '✅ Valid' : '❌ Invalid'}`);
        console.log(`Errors: ${errors.length}`);
        console.log(`Warnings: ${warnings.length}`);
    }
    displayTableResult(result, options) {
        const { target, isValid, errors, warnings, validationType } = result;
        console.log(`\n🔍 Validation Report for ${target}`);
        console.log(`${'='.repeat(50)}`);
        console.log(`Type: ${validationType}`);
        console.log(`Status: ${isValid ? '✅ Valid' : '❌ Invalid'}`);
        console.log(`Errors: ${errors.length}`);
        console.log(`Warnings: ${warnings.length}`);
        console.log();
        // Display errors
        if (errors.length > 0) {
            console.log('🚨 Errors:');
            console.log('─'.repeat(30));
            errors.forEach((error, index) => {
                console.log(`${index + 1}. ${error.field}: ${error.message}`);
                if (error.line !== undefined) {
                    console.log(`   Line: ${error.line}${error.column ? `, Column: ${error.column}` : ''}`);
                }
                console.log(`   Code: ${error.code}\n`);
            });
        }
        // Display warnings (unless skipped)
        if (warnings.length > 0 && !options.skipWarnings) {
            console.log('⚠️  Warnings:');
            console.log('─'.repeat(30));
            warnings.forEach((warning, index) => {
                console.log(`${index + 1}. ${warning.field}: ${warning.message}`);
                if (warning.line !== undefined) {
                    console.log(`   Line: ${warning.line}${warning.column ? `, Column: ${warning.column}` : ''}`);
                }
                console.log(`   Code: ${warning.code}\n`);
            });
        }
        // Display success message
        if (isValid) {
            console.log('✅ Validation passed successfully!');
            if (warnings.length > 0) {
                console.log(`   Note: ${warnings.length} warning${warnings.length > 1 ? 's' : ''} found`);
            }
        }
        else {
            console.log('❌ Validation failed. Please fix the errors above.');
        }
        console.log();
    }
}
exports.ValidateCommandHandler = ValidateCommandHandler;