snap-validate 0.3.3 → 0.4.0

package/README.md

@@ -6,6 +6,7 @@
 [![install size](https://img.shields.io/badge/dynamic/json?url=https://packagephobia.com/v2/api.json?p=snap-validate&query=$.install.pretty&label=install%20size&style=flat-square)](https://packagephobia.now.sh/result?p=snap-validate)
 [![npm bundle size](https://img.shields.io/bundlephobia/minzip/snap-validate?style=flat-square)](https://bundlephobia.com/package/snap-validate@latest)
 [![npm downloads](https://img.shields.io/npm/dm/snap-validate.svg?style=flat-square)](https://npm-stat.com/charts.html?package=snap-validate)
+![Codecov](https://img.shields.io/codecov/c/github/aniru-dh21/snap-validate)
 
 A lightning-fast, lightweight validation library for common patterns without heavy dependencies. Perfect for client-side and server-side validation with zero external dependencies and built-in protection against ReDoS (Regular Expression Denial of Service) attacks.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snap-validate",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Lightweight validation library for common patterns without heavy dependencies",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/index.js

@@ -1,18 +1,16 @@
 /**
  * Snap Validate - Enhanced Lightweight validator library
- * @version 0.3.2 - Typescript Patch
+ * @version 0.4.0 - Phase 1: Arrays, Nested Objects, Transforms
  */
 
 // Utility function to safely test regex with timeout protection
 const safeRegexTest = (regex, str, timeoutMs = 1000) => {
   return new Promise((resolve, reject) => {
-    // SECURITY FIX: Add input length validation before regex test
     if (str.length > 10000) {
       reject(new Error('Input too long for regex validation'));
       return;
     }
 
-    // SECURITY FIX: Add regex safety check before execution
     if (!isRegexSafe(regex)) {
       reject(new Error('Unsafe regex pattern detected'));
       return;
@@ -35,13 +33,9 @@ const safeRegexTest = (regex, str, timeoutMs = 1000) => {
 
 // Synchronous safe regex test with input length protection
 const safeRegexTestSync = (regex, str, maxLength = 10000) => {
-  // Limit input length to prevent ReDoS
   if (str.length > maxLength) {
     throw new Error('Input too long for pattern validation');
   }
-
-  // For additional safety, we could add a timeout using a worker thread or 
-  // other mechanism, but for now we rely on input length limiting
   return regex.test(str);
 };
 
@@ -49,21 +43,14 @@ const safeRegexTestSync = (regex, str, maxLength = 10000) => {
 const isRegexSafe = (regex) => {
   const regexStr = regex.toString();
 
-  // Check for common ReDoS patterns - more precise detection
   const dangerousPatterns = [
-    // Nested quantifiers like (a+)+ or (a*)* or (a?)?
     /\([^)]*[+*?][^)]*\)[+*?]/,
-    // Alternation with overlapping and quantifiers like (a|a)*
     /\([^)]*\|[^)]*\)[+*]/,
-    // Catastrophic backtracking with greedy quantifiers
     /\([^)]*\.\*[^)]*\)\*/,
-    // Multiple consecutive quantifiers (not separated by characters)
     /[+*?]{2,}/,
-    // Exponential alternation patterns
     /\([^)]*\|[^)]*\)\+.*\([^)]*\|[^)]*\)\+/
   ];
 
-  // Check if the pattern has obvious ReDoS vulnerabilities
   const isDangerous = dangerousPatterns.some((pattern) =>
     pattern.test(regexStr)
   );
@@ -92,12 +79,29 @@ class BaseValidator {
     this.rules = [];
     this.asyncRules = [];
     this.isOptional = false;
-    this.regexTimeout = 1000; // Default timeout for regex operations
+    this.regexTimeout = 1000;
+    this.fieldName = null; // Track field name for better error messages
+  }
+
+  // Set field name for contextual error messages
+  setFieldName(name) {
+    this.fieldName = name;
+    return this;
+  }
+
+  // Helper to format error messages with field context
+  _formatError(message) {
+    if (
+      this.fieldName &&
+      !message.toLowerCase().includes(this.fieldName.toLowerCase())
+    ) {
+      return `${this.fieldName}: ${message}`;
+    }
+    return message;
   }
 
   required(message = 'This field is required') {
     this.rules.push(() => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -110,7 +114,7 @@ class BaseValidator {
         this.value === undefined ||
         this.value === ''
       ) {
-        return new ValidationResult(false, [message]);
+        return new ValidationResult(false, [this._formatError(message)]);
       }
       return new ValidationResult(true);
     });
@@ -127,9 +131,91 @@ class BaseValidator {
     return this;
   }
 
+  // Transform/sanitize data before validation
+  transform(fn, errorMessage = 'Transform function failed') {
+    this.rules.push(() => {
+      if (this.value != null && this.value !== '') {
+        try {
+          this.value = fn(this.value);
+        } catch (error) {
+          return new ValidationResult(false, [
+            this._formatError(`${errorMessage}: ${error.message}`)
+          ]);
+        }
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  // Check if value equals another value
+  equals(compareValue, message) {
+    const defaultMessage = `Must equal ${compareValue}`;
+    this.rules.push(() => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined || this.value === '')
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (this.value !== compareValue) {
+        return new ValidationResult(false, [
+          this._formatError(message || defaultMessage)
+        ]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  // Check if value is one of allowed values
+  oneOf(allowedValues, message) {
+    const defaultMessage = `Must be one of: ${allowedValues.join(', ')}`;
+    this.rules.push(() => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined || this.value === '')
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (!allowedValues.includes(this.value)) {
+        return new ValidationResult(false, [
+          this._formatError(message || defaultMessage)
+        ]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  // Check if value is between min and max (for numbers)
+  between(min, max, message) {
+    const defaultMessage = `Must be between ${min} and ${max}`;
+    this.rules.push(() => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined || this.value === '')
+      ) {
+        return new ValidationResult(true);
+      }
+
+      const numValue =
+        typeof this.value === 'number' ? this.value : parseFloat(this.value);
+
+      if (isNaN(numValue) || numValue < min || numValue > max) {
+        return new ValidationResult(false, [
+          this._formatError(message || defaultMessage)
+        ]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
   min(length, message = `Minimum length is ${length}`) {
     this.rules.push(() => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -137,21 +223,18 @@ class BaseValidator {
         return new ValidationResult(true);
       }
 
-      // Only validate if value exists and a length property
       if (this.value != null && this.value !== '') {
-        // Check if value has length property (string, array)
         if (typeof this.value === 'string' || Array.isArray(this.value)) {
           if (this.value.length < length) {
-            return new ValidationResult(false, [message]);
+            return new ValidationResult(false, [this._formatError(message)]);
           }
         } else if (typeof this.value === 'number') {
-          // For numbers, compare the value itself
           if (this.value < length) {
-            return new ValidationResult(false, [message]);
+            return new ValidationResult(false, [this._formatError(message)]);
           }
         } else {
           return new ValidationResult(false, [
-            'Value must be a string, array, or number'
+            this._formatError('Value must be a string, array, or number')
           ]);
         }
       }
@@ -162,7 +245,6 @@ class BaseValidator {
 
   max(length, message = `Maximum length is ${length}`) {
     this.rules.push(() => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -170,21 +252,18 @@ class BaseValidator {
         return new ValidationResult(true);
       }
 
-      // Only validate if value exists and has a length property
       if (this.value != null && this.value !== '') {
-        // Check if value has length property (string, array)
         if (typeof this.value === 'string' || Array.isArray(this.value)) {
           if (this.value.length > length) {
-            return new ValidationResult(false, [message]);
+            return new ValidationResult(false, [this._formatError(message)]);
           }
         } else if (typeof this.value === 'number') {
-          // For numbers, compare the value itself
           if (this.value > length) {
-            return new ValidationResult(false, [message]);
+            return new ValidationResult(false, [this._formatError(message)]);
           }
         } else {
           return new ValidationResult(false, [
-            'Value must be a string, array or number'
+            this._formatError('Value must be a string, array or number')
           ]);
         }
       }
@@ -193,8 +272,198 @@ class BaseValidator {
     return this;
   }
 
+  // Validate that value is an array
+  array(message = 'Must be an array') {
+    this.rules.push(() => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined)
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (!Array.isArray(this.value)) {
+        return new ValidationResult(false, [this._formatError(message)]);
+      }
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  // Validate each item in an array
+  arrayOf(validator, message = 'Invalid array items') {
+    this.rules.push(() => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined)
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (!Array.isArray(this.value)) {
+        return new ValidationResult(false, [
+          this._formatError('Value must be an array')
+        ]);
+      }
+
+      const errors = [];
+      this.value.forEach((item, index) => {
+        try {
+          const itemValidator =
+            typeof validator === 'function' ? validator(item) : validator;
+          const result = itemValidator.validate();
+
+          if (!result.isValid) {
+            errors.push(`[${index}]: ${result.errors.join(', ')}`);
+          }
+        } catch (error) {
+          errors.push(`[${index}]: Validation error - ${error.message}`);
+        }
+      });
+
+      if (errors.length > 0) {
+        return new ValidationResult(false, [
+          this._formatError(`${message}: ${errors.join('; ')}`)
+        ]);
+      }
+
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  // Async array validation
+  arrayOfAsync(validator, message = 'Invalid array items') {
+    this.asyncRules.push(async () => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined)
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (!Array.isArray(this.value)) {
+        return new ValidationResult(false, [
+          this._formatError('Value must be an array')
+        ]);
+      }
+
+      const errors = [];
+      for (let index = 0; index < this.value.length; index++) {
+        try {
+          const item = this.value[index];
+          const itemValidator =
+            typeof validator === 'function' ? validator(item) : validator;
+
+          const result =
+            itemValidator.asyncRules && itemValidator.asyncRules.length > 0
+              ? await itemValidator.validateAsync()
+              : itemValidator.validate();
+
+          if (!result.isValid) {
+            errors.push(`[${index}]: ${result.errors.join(', ')}`);
+          }
+        } catch (error) {
+          errors.push(`[${index}]: Validation error - ${error.message}`);
+        }
+      }
+
+      if (errors.length > 0) {
+        return new ValidationResult(false, [
+          this._formatError(`${message}: ${errors.join('; ')}`)
+        ]);
+      }
+
+      return new ValidationResult(true);
+    });
+    return this;
+  }
+
+  // Validate nested objects
+  object(schema, message = 'Invalid object structure') {
+    this.rules.push(() => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined)
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (
+        typeof this.value !== 'object' ||
+        this.value === null ||
+        Array.isArray(this.value)
+      ) {
+        return new ValidationResult(false, [this._formatError(message)]);
+      }
+
+      try {
+        const result = validate(schema, this.value);
+
+        if (!result.isValid) {
+          const fieldErrors = result.getErrors();
+          const errorMessages = Object.entries(fieldErrors)
+            .map(([field, errs]) => `${field}: ${errs.join(', ')}`)
+            .join('; ');
+
+          return new ValidationResult(false, [
+            this._formatError(`Object validation failed - ${errorMessages}`)
+          ]);
+        }
+
+        return new ValidationResult(true);
+      } catch (error) {
+        return new ValidationResult(false, [
+          this._formatError(`Object validation error: ${error.message}`)
+        ]);
+      }
+    });
+    return this;
+  }
+
+  // Async nested object validation
+  objectAsync(schema, message = 'Invalid object structure') {
+    this.asyncRules.push(async () => {
+      if (
+        this.isOptional &&
+        (this.value === null || this.value === undefined)
+      ) {
+        return new ValidationResult(true);
+      }
+
+      if (
+        typeof this.value !== 'object' ||
+        this.value === null ||
+        Array.isArray(this.value)
+      ) {
+        return new ValidationResult(false, [this._formatError(message)]);
+      }
+
+      try {
+        const result = await validateAsync(schema, this.value);
+
+        if (!result.isValid) {
+          const fieldErrors = result.getErrors();
+          const errorMessages = Object.entries(fieldErrors)
+            .map(([field, errs]) => `${field}: ${errs.join(', ')}`)
+            .join('; ');
+
+          return new ValidationResult(false, [
+            this._formatError(`Object validation failed - ${errorMessages}`)
+          ]);
+        }
+
+        return new ValidationResult(true);
+      } catch (error) {
+        return new ValidationResult(false, [
+          this._formatError(`Object validation error: ${error.message}`)
+        ]);
+      }
+    });
+    return this;
+  }
+
   pattern(regex, message = 'Invalid format') {
-    // SECURITY FIX: Add regex safety check
     if (!isRegexSafe(regex)) {
       throw new Error(
         'Potentially unsafe regex pattern detected. Please use a simple pattern.'
@@ -202,7 +471,6 @@ class BaseValidator {
     }
 
     this.rules.push(() => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -210,23 +478,22 @@ class BaseValidator {
         return new ValidationResult(true);
       }
 
-      // Only test pattern if value exists and is not empty
       if (this.value != null && this.value !== '') {
-        // Ensure value is a string before testing regex
         const stringValue = String(this.value);
 
         try {
-          // SECURITY FIX: Use safe regex test with input length protection
           if (!safeRegexTestSync(regex, stringValue)) {
-            return new ValidationResult(false, [message]);
+            return new ValidationResult(false, [this._formatError(message)]);
           }
         } catch (error) {
           if (error.message.includes('Input too long')) {
             return new ValidationResult(false, [
-              'Input too long for pattern validation'
+              this._formatError('Input too long for pattern validation')
             ]);
           }
-          return new ValidationResult(false, ['Pattern validation failed']);
+          return new ValidationResult(false, [
+            this._formatError('Pattern validation failed')
+          ]);
         }
       }
       return new ValidationResult(true);
@@ -234,9 +501,7 @@ class BaseValidator {
     return this;
   }
 
-  // New method for async pattern validation with timeout protection
   patternAsync(regex, message = 'Invalid format') {
-    // Security Fix: Add regex safety check
     if (!isRegexSafe(regex)) {
       throw new Error(
         'Potentially unsafe regex pattern detected. Please use a simple pattern.'
@@ -244,7 +509,6 @@ class BaseValidator {
     }
 
     this.asyncRules.push(async () => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -252,35 +516,35 @@ class BaseValidator {
         return new ValidationResult(true);
       }
 
-      // Only test pattern if value exists and is not empty
       if (this.value != null && this.value !== '') {
-        // Ensure value is a string before testing regex
         const stringValue = String(this.value);
 
-        // Security Fix: Limit input length to prevent ReDoS
         if (stringValue.length > 10000) {
           return new ValidationResult(false, [
-            'Input too long for pattern validation'
+            this._formatError('Input too long for pattern validation')
           ]);
         }
 
         try {
-          // Security Fix: Use timeout protection for regex execution
           const result = await safeRegexTest(
             regex,
             stringValue,
             this.regexTimeout
           );
           if (!result) {
-            return new ValidationResult(false, [message]);
+            return new ValidationResult(false, [this._formatError(message)]);
           }
         } catch (error) {
           if (error.message.includes('timeout')) {
             return new ValidationResult(false, [
-              'Pattern validation timeout - pattern too complex'
+              this._formatError(
+                'Pattern validation timeout - pattern too complex'
+              )
             ]);
           }
-          return new ValidationResult(false, ['Pattern validation failed']);
+          return new ValidationResult(false, [
+            this._formatError('Pattern validation failed')
+          ]);
         }
       }
       return new ValidationResult(true);
@@ -290,17 +554,14 @@ class BaseValidator {
 
   when(condition, validator) {
     this.rules.push(() => {
-      // Evaluate condition
       const shouldValidate =
         typeof condition === 'function' ? condition(this.value) : condition;
 
       if (shouldValidate) {
-        // Apply the conditional validator
         if (typeof validator === 'function') {
           const conditionalValidator = validator(this.value);
           return conditionalValidator.validate();
         } else {
-          // If validator is already a BaseValidator instance
           return validator.validate();
         }
       }
@@ -312,7 +573,6 @@ class BaseValidator {
 
   custom(validatorFn, message = 'Custom validation failed') {
     this.rules.push(() => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -323,28 +583,24 @@ class BaseValidator {
       try {
         const result = validatorFn(this.value);
 
-        // Handle boolean result
         if (typeof result === 'boolean') {
           return result
             ? new ValidationResult(true)
-            : new ValidationResult(false, [message]);
+            : new ValidationResult(false, [this._formatError(message)]);
         }
 
-        // Handle ValidationResult object
         if (result && typeof result === 'object' && 'isValid' in result) {
           return result;
         }
 
-        // Handle string result (error message)
         if (typeof result === 'string') {
-          return new ValidationResult(false, [result]);
+          return new ValidationResult(false, [this._formatError(result)]);
         }
 
-        // Default to true if no clear result
         return new ValidationResult(true);
       } catch (error) {
         return new ValidationResult(false, [
-          `Custom validation error: ${error.message}`
+          this._formatError(`Custom validation error: ${error.message}`)
         ]);
       }
     });
@@ -353,7 +609,6 @@ class BaseValidator {
 
   customAsync(validatorFn, message = 'Async validation failed') {
     this.asyncRules.push(async () => {
-      // Skip validation if optional and empty
       if (
         this.isOptional &&
         (this.value === null || this.value === undefined || this.value === '')
@@ -364,28 +619,24 @@ class BaseValidator {
       try {
         const result = await validatorFn(this.value);
 
-        // Handle boolean result
         if (typeof result === 'boolean') {
           return result
             ? new ValidationResult(true)
-            : new ValidationResult(false, [message]);
+            : new ValidationResult(false, [this._formatError(message)]);
         }
 
-        // Handle ValidationResult object
         if (result && typeof result === 'object' && 'isValid' in result) {
           return result;
         }
 
-        // Handle string result (error message)
         if (typeof result === 'string') {
-          return new ValidationResult(false, [result]);
+          return new ValidationResult(false, [this._formatError(result)]);
         }
 
-        // Default to true if no clear result
         return new ValidationResult(true);
       } catch (error) {
         return new ValidationResult(false, [
-          `Async validation error: ${error.message}`
+          this._formatError(`Async validation error: ${error.message}`)
         ]);
       }
     });
@@ -403,9 +654,10 @@ class BaseValidator {
           result.errors.push(...ruleResult.errors);
         }
       } catch (error) {
-        // Handle any unexpected errors during validation
         result.isValid = false;
-        result.errors.push(`Validation error: ${error.message}`);
+        result.errors.push(
+          this._formatError(`Validation error: ${error.message}`)
+        );
       }
     }
 
@@ -413,14 +665,12 @@ class BaseValidator {
   }
 
   async validateAsync() {
-    // First run synchronous validations
     const syncResult = this.validate();
 
     if (!syncResult.isValid) {
       return syncResult;
     }
 
-    // Then run asynchronous validations
     const result = new ValidationResult(true, [...syncResult.errors]);
 
     for (const asyncRule of this.asyncRules) {
@@ -431,9 +681,10 @@ class BaseValidator {
           result.errors.push(...ruleResult.errors);
         }
       } catch (error) {
-        // Handle any unexpected errors during async validation
         result.isValid = false;
-        result.errors.push(`Async validation error: ${error.message}`);
+        result.errors.push(
+          this._formatError(`Async validation error: ${error.message}`)
+        );
       }
     }
 
@@ -442,17 +693,16 @@ class BaseValidator {
 }
 
 // Predefined validators
-// Security Fix: Updated predefined validators with safer regex patterns
 const validators = {
   email: (value) => {
     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return new BaseValidator(value)
+      .transform((v) => (typeof v === 'string' ? v.trim().toLowerCase() : v))
       .required('Email is required')
       .pattern(emailRegex, 'Invalid email format');
   },
 
   phone: (value, format = 'us') => {
-    // FIXED: Much simpler phone regex patterns to avoid ReDoS detection
     const phoneRegex = {
       us: /^[+]?[1]?[0-9]{10}$/,
       international: /^[+][1-9][0-9]{7,14}$/,
@@ -462,7 +712,6 @@ const validators = {
     return new BaseValidator(value)
       .required('Phone number is required')
       .custom((val) => {
-        // Remove all non-digit characters except +
         const cleaned = String(val).replace(/[^+0-9]/g, '');
         const regex = phoneRegex[format] || phoneRegex.simple;
 
@@ -474,12 +723,10 @@ const validators = {
   },
 
   creditCard: (value) => {
-    // Luhn algorithm check
     const luhnCheck = (num) => {
       let sum = 0;
       let isEven = false;
 
-      // Remove spaces and ensure we have a string
       const cleanNum = String(num).replace(/\s/g, '');
 
       for (let i = cleanNum.length - 1; i >= 0; i--) {
@@ -501,9 +748,7 @@ const validators = {
       'Credit card number is required'
     );
 
-    // Add custom validation for credit card format and Luhn check
     validator.rules.push(() => {
-      // Skip validation if optional and empty
       if (
         validator.isOptional &&
         (validator.value === null ||
@@ -516,14 +761,12 @@ const validators = {
       if (validator.value) {
         const cleanValue = String(validator.value).replace(/\s/g, '');
 
-        // Check length (13-19 digits) using safe regex
         if (!safeRegexTestSync(/^\d{13,19}$/, cleanValue)) {
           return new ValidationResult(false, [
             'Credit card must be 13-19 digits'
           ]);
         }
 
-        // Check Luhn algorithm
         if (!luhnCheck(cleanValue)) {
           return new ValidationResult(false, ['Invalid credit card number']);
         }
@@ -606,7 +849,6 @@ const validators = {
 
 // Main validation function
 const validate = (schema, data) => {
-  // Input validation
   if (!schema || typeof schema !== 'object') {
     throw new Error('Schema must be a valid object');
   }
@@ -621,19 +863,21 @@ const validate = (schema, data) => {
   for (const [field, validator] of Object.entries(schema)) {
     try {
       const fieldValue = data[field];
-      const result =
-        typeof validator === 'function'
-          ? validator(fieldValue).validate()
-          : validator.validate();
+      const validatorInstance =
+        typeof validator === 'function' ? validator(fieldValue) : validator;
+
+      // Set field name for better error context
+      validatorInstance.setFieldName(field);
+
+      const result = validatorInstance.validate();
 
       results[field] = result;
       if (!result.isValid) {
         isValid = false;
       }
     } catch (error) {
-      // Handle validation setup errors
       results[field] = new ValidationResult(false, [
-        `Validation setup error: ${error.message}`
+        `${field}: Validation setup error - ${error.message}`
       ]);
       isValid = false;
     }
@@ -656,7 +900,6 @@ const validate = (schema, data) => {
 
 // Async validation function
 const validateAsync = async (schema, data) => {
-  // Input validation
   if (!schema || typeof schema !== 'object') {
     throw new Error('Schema must be a valid object');
   }
@@ -672,28 +915,24 @@ const validateAsync = async (schema, data) => {
     try {
       const fieldValue = data[field];
 
-      let result;
-      if (typeof validator === 'function') {
-        const validatorInstance = validator(fieldValue);
-        result =
-          validatorInstance.asyncRules.length > 0
-            ? await validatorInstance.validateAsync()
-            : validatorInstance.validate();
-      } else {
-        result =
-          validator.asyncRules && validator.asyncRules.length > 0
-            ? await validator.validateAsync()
-            : validator.validate();
-      }
+      const validatorInstance =
+        typeof validator === 'function' ? validator(fieldValue) : validator;
+
+      // Set field name for better error context
+      validatorInstance.setFieldName(field);
+
+      const result =
+        validatorInstance.asyncRules && validatorInstance.asyncRules.length > 0
+          ? await validatorInstance.validateAsync()
+          : validatorInstance.validate();
 
       results[field] = result;
       if (!result.isValid) {
         isValid = false;
       }
     } catch (error) {
-      // Handle validation setup errors
       results[field] = new ValidationResult(false, [
-        `Validation setup error: ${error.message}`
+        `${field}: Validation setup error - ${error.message}`
       ]);
       isValid = false;
     }
@@ -723,4 +962,4 @@ module.exports = {
   safeRegexTest,
   safeRegexTestSync,
   isRegexSafe
-};
+};