sfcc-dev-mcp/dist/core/handlers/validation-helpers.js

MCP server for Salesforce B2C Commerce Cloud development assistance including logs, debugging, and development tools

/**
 * Validation helpers for handler arguments
 */
import { HandlerError } from './base-handler.js';
export class ValidationHelpers {
    /**
     * Validate arguments against a set of rules
     */
    static validateArguments(args, rules, toolName) {
        for (const rule of rules) {
            const value = args?.[rule.field];
            // Check required fields
            if (rule.required && (value === undefined || value === null || value === '')) {
                throw new HandlerError(rule.errorMessage ?? `${rule.field} is required`, toolName, 'MISSING_ARGUMENT', { field: rule.field, rules });
            }
            // Skip type and custom validation if value is not present and not required
            if (!rule.required && (value === undefined || value === null)) {
                continue;
            }
            // Check type (including for required fields that have values)
            if (rule.type && value !== undefined && value !== null && !this.validateType(value, rule.type)) {
                throw new HandlerError(rule.errorMessage ?? `${rule.field} must be of type ${rule.type}`, toolName, 'INVALID_TYPE', { field: rule.field, expectedType: rule.type, actualType: typeof value });
            }
            // Custom validation
            if (rule.validator && !rule.validator(value)) {
                throw new HandlerError(rule.errorMessage ?? `${rule.field} validation failed`, toolName, 'VALIDATION_FAILED', { field: rule.field, value });
            }
        }
    }
    /**
     * Quick validation for required string fields
     * @deprecated Use CommonValidations.requiredString() with validateArguments() instead
     * @example
     * // Old way
     * ValidationHelpers.requireStrings(args, ['fieldName'], 'tool_name');
     *
     * // New way
     * ValidationHelpers.validateArguments(args, CommonValidations.requiredString('fieldName'), 'tool_name');
     */
    static requireStrings(args, fields, toolName) {
        const rules = fields.map(field => ({
            field,
            required: true,
            type: 'string',
            errorMessage: `${field} is required for ${toolName}`,
        }));
        this.validateArguments(args, rules, toolName);
    }
    /**
     * Validate a single field with custom validator
     */
    static validateField(args, field, validator, errorMessage, toolName) {
        const rules = [{
                field,
                validator,
                errorMessage,
            }];
        this.validateArguments(args, rules, toolName);
    }
    static validateType(value, type) {
        switch (type) {
            case 'string':
                return typeof value === 'string';
            case 'number':
                return typeof value === 'number' && !isNaN(value);
            case 'boolean':
                return typeof value === 'boolean';
            case 'object':
                return typeof value === 'object' && value !== null && !Array.isArray(value);
            case 'array':
                return Array.isArray(value);
            default:
                return true;
        }
    }
}
/**
 * Common validation rules factory
 */
export const CommonValidations = {
    /**
     * Create a required string field validation
     */
    requiredString: (field, customMessage) => [{
            field,
            required: true,
            type: 'string',
            validator: (value) => value.trim().length > 0,
            errorMessage: customMessage ?? `${field} must be a non-empty string`,
        }],
    /**
     * Create a required field validation with custom validator
     */
    requiredField: (field, type, validator, errorMessage) => [{
            field,
            required: true,
            type,
            validator,
            errorMessage,
        }],
    /**
     * Create an optional field validation
     */
    optionalField: (field, type, validator, errorMessage) => [{
            field,
            required: false,
            type,
            validator,
            errorMessage,
        }],
};
//# sourceMappingURL=validation-helpers.js.map