Parameters, Arguments, and Return Values

Practical Exercise: Building a Validation Library

Let's apply our knowledge of parameters, arguments, and return values to build a flexible validation library.

// Validation library using various parameter and return patterns
const Validator = (function() {
    // Private utility functions
    function isString(value) {
        return typeof value === 'string';
    }
    
    function isNumber(value) {
        return typeof value === 'number' && !isNaN(value);
    }
    
    function isArray(value) {
        return Array.isArray(value);
    }
    
    function isFunction(value) {
        return typeof value === 'function';
    }
    
    // Basic validation functions - return boolean
    function required(value) {
        return value !== undefined && value !== null && value !== '';
    }
    
    function minLength(min) {
        // Returns a function (higher-order function pattern)
        return function(value) {
            if (!isString(value)) return false;
            return value.length >= min;
        };
    }
    
    function maxLength(max) {
        return function(value) {
            if (!isString(value)) return false;
            return value.length <= max;
        };
    }
    
    function minValue(min) {
        return function(value) {
            if (!isNumber(value)) return false;
            return value >= min;
        };
    }
    
    function maxValue(max) {
        return function(value) {
            if (!isNumber(value)) return false;
            return value <= max;
        };
    }
    
    function pattern(regex) {
        return function(value) {
            if (!isString(value)) return false;
            return regex.test(value);
        };
    }
    
    // Pattern for common validations
    const patterns = {
        email: pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/),
        url: pattern(/^https?:\/\/.+\..+/),
        alphanumeric: pattern(/^[a-zA-Z0-9]+$/),
        numeric: pattern(/^[0-9]+$/)
    };
    
    // Enhanced validator with detailed result
    function validate(value, validatorFn) {
        const isValid = validatorFn(value);
        
        return {
            value,
            isValid,
            message: isValid ? null : 'Validation failed'
        };
    }
    
    // Composite validator that runs multiple validations
    function validateAll(value, validators, { stopOnFailure = false } = {}) {
        if (!isArray(validators)) {
            throw new Error('Validators must be an array');
        }
        
        const results = [];
        let allValid = true;
        
        for (const validator of validators) {
            // Support for validator functions or objects with validator and message
            let validatorFn;
            let message;
            
            if (isFunction(validator)) {
                validatorFn = validator;
                message = 'Validation failed';
            } else if (validator && isFunction(validator.validate)) {
                validatorFn = validator.validate;
                message = validator.message || 'Validation failed';
            } else {
                throw new Error('Invalid validator');
            }
            
            const isValid = validatorFn(value);
            
            results.push({
                isValid,
                message: isValid ? null : message
            });
            
            if (!isValid) {
                allValid = false;
                if (stopOnFailure) break;
            }
        }
        
        return {
            value,
            results,
            isValid: allValid,
            errors: results.filter(r => !r.isValid).map(r => r.message)
        };
    }
    
    // Create a named validator with custom message
    function createValidator(name, validatorFn, message) {
        return {
            name,
            validate: validatorFn,
            message
        };
    }
    
    // Form validation with object destructuring and default parameters
    function validateForm(formData, validationSchema, options = {}) {
        const { stopOnFirstError = false } = options;
        
        const results = {};
        let isFormValid = true;
        
        // Process each field in the validation schema
        for (const [fieldName, fieldValidators] of Object.entries(validationSchema)) {
            // Get field value from formData
            const value = formData[fieldName];
            
            // Validate the field
            const fieldResult = validateAll(value, fieldValidators);
            
            // Store result for this field
            results[fieldName] = fieldResult;
            
            // Update overall form validity
            if (!fieldResult.isValid) {
                isFormValid = false;
                if (stopOnFirstError) break;
            }
        }
        
        return {
            isValid: isFormValid,
            fields: results,
            // Helper method to get all error messages
            getAllErrors() {
                const errors = {};
                for (const [field, result] of Object.entries(this.fields)) {
                    if (!result.isValid) {
                        errors[field] = result.errors;
                    }
                }
                return errors;
            }
        };
    }
    
    // Public API
    return {
        // Basic validators
        required,
        minLength,
        maxLength,
        minValue,
        maxValue,
        pattern,
        patterns,
        
        // Enhanced validation
        validate,
        validateAll,
        createValidator,
        validateForm
    };
})();

// Example usage
const emailValidator = Validator.createValidator(
    'email',
    Validator.patterns.email,
    'Please enter a valid email address'
);

const passwordValidator = Validator.createValidator(
    'password',
    Validator.minLength(8),
    'Password must be at least 8 characters long'
);

// Define validation schema
const userFormValidations = {
    username: [
        Validator.createValidator('required', Validator.required, 'Username is required'),
        Validator.createValidator('alphanumeric', Validator.patterns.alphanumeric, 'Username must contain only letters and numbers'),
        Validator.createValidator('length', Validator.minLength(3), 'Username must be at least 3 characters long')
    ],
    email: [
        Validator.createValidator('required', Validator.required, 'Email is required'),
        emailValidator
    ],
    password: [
        Validator.createValidator('required', Validator.required, 'Password is required'),
        passwordValidator
    ],
    age: [
        Validator.createValidator('required', Validator.required, 'Age is required'),
        Validator.createValidator('min', Validator.minValue(18), 'You must be at least 18 years old'),
        Validator.createValidator('max', Validator.maxValue(120), 'Age must be realistic')
    ]
};

// Test the validation
const formData = {
    username: 'john123',
    email: 'john@example.com',
    password: 'password123',
    age: 25
};

const validationResult = Validator.validateForm(formData, userFormValidations);
console.log('Form is valid:', validationResult.isValid);

// Test with invalid data
const invalidFormData = {
    username: 'j@',
    email: 'not-an-email',
    password: 'short',
    age: 15
};

const invalidResult = Validator.validateForm(invalidFormData, userFormValidations);
console.log('Form is valid:', invalidResult.isValid);
console.log('Validation errors:', invalidResult.getAllErrors());