Snap Validate: A Lightning-Fast Validation Library for JavaScript

Data validation is crucial in any application, but most validation libraries come with heavy dependencies and complex APIs. What if you could have powerful validation without the bloat? Meet Snap Validate - a lightweight, lightning-fast validation library that gets the job done without compromising on features.

Why Another Validation Library?

When building applications, you often need to validate:

• Email addresses

• Phone numbers

• Credit card numbers

• URLs

• Passwords

• Custom business logic

Most existing libraries either lack features or come with unnecessary dependencies. Snap Validate solves this by providing:

• ⚡ Zero dependencies - No external packages

• 🚀 Lightning fast - Optimized for performance

• 🔒 Security first - Built-in protection against ReDoS attacks

• 🔧 Flexible - Chainable API with custom validators

Getting Started

Installation is simple:

npm install snap-validate

Basic usage:

const { validators, validate } = require('snap-validate');

// Single field validation
const emailResult = validators.email('user@example.com').validate();
console.log(emailResult.isValid); // true

// Schema validation
const schema = {
  email: validators.email,
  phone: (value) => validators.phone(value, 'us'),
  password: validators.password
};

const data = {
  email: 'user@example.com',
  phone: '(555) 123-4567',
  password: 'SecurePass123'
};

const result = validate(schema, data);
console.log(result.isValid); // true

Common Validation Patterns

Email Validation

validators.email('user@example.com').validate();

Phone Number Validation

// US format
validators.phone('(555) 123-4567').validate();

// International format
validators.phone('+1234567890', 'international').validate();

Credit Card Validation

// Uses Luhn algorithm
validators.creditCard('4532015112830366').validate();

Password Validation

// Default requirements
validators.password('SecurePass123').validate();

// Custom requirements
validators.password('MyPass123!', {
  minLength: 10,
  requireUppercase: true,
  requireSpecialChars: true
}).validate();

Advanced Features

Chainable Validation

const { BaseValidator } = require('snap-validate');

const validator = new BaseValidator('test-value')
  .required('This field is required')
  .min(5, 'Must be at least 5 characters')
  .max(20, 'Must be no more than 20 characters')
  .pattern(/^[a-zA-Z]+$/, 'Only letters allowed');

const result = validator.validate();

Conditional Validation

// Validate only when condition is met
const validator = new BaseValidator(value)
  .when(user.isAdmin, validators.required('Admin field required'))
  .min(5, 'Must be at least 5 characters');

// Optional validation
const optionalValidator = new BaseValidator(value)
  .optional()
  .email('Must be a valid email if provided');

Custom Validators

// Synchronous custom validation
const customValidator = new BaseValidator(value)
  .custom((val) => val !== 'forbidden', 'Value cannot be forbidden')
  .required();

// Asynchronous custom validation
const asyncValidator = new BaseValidator(email)
  .email()
  .customAsync(async (email) => {
    const exists = await checkEmailExists(email);
    return !exists || 'Email already exists';
  }, 'Email validation failed');

const result = await asyncValidator.validateAsync();

Security First Approach

One of the standout features of Snap Validate is its built-in security. The library protects against ReDoS (Regular Expression Denial of Service) attacks by:

• Detecting potentially dangerous regex patterns

• Limiting input length to prevent attacks

• Providing configurable timeout protection

• Using safe, optimized regex patterns by default

// Set custom timeout for regex operations
const validator = new BaseValidator(value)
  .setRegexTimeout(2000) // 2 second timeout
  .pattern(/your-pattern/, 'Error message');

Real-World Example: User Registration

Here's how you might validate a user registration form:

const { validators, validate, BaseValidator } = require('snap-validate');

const registrationSchema = {
  username: (value) => new BaseValidator(value)
    .required('Username is required')
    .min(3, 'Username must be at least 3 characters')
    .max(20, 'Username must be less than 20 characters')
    .pattern(/^[a-zA-Z0-9_]+$/, 'Username can only contain letters, numbers, and underscores'),

  email: validators.email,

  password: (value) => validators.password(value, {
    minLength: 8,
    requireUppercase: true,
    requireLowercase: true,
    requireNumbers: true,
    requireSpecialChars: true
  }),

  phone: (value) => validators.phone(value, 'us'),

  age: (value) => new BaseValidator(value)
    .required('Age is required')
    .pattern(/^\d+$/, 'Age must be a number')
    .custom((val) => parseInt(val) >= 18, 'Must be 18 or older')
};

const userData = {
  username: 'john_doe',
  email: 'john@example.com',
  password: 'SecurePass123!',
  phone: '(555) 123-4567',
  age: '25'
};

const result = validate(registrationSchema, userData);

if (result.isValid) {
  console.log('Registration data is valid!');
} else {
  console.log('Validation errors:', result.getErrors());
}

Error Handling

Snap Validate provides clear, helpful error messages:

const result = validators.email('invalid-email').validate();

if (!result.isValid) {
  console.log('Validation errors:', result.errors);
  // Output: ['Invalid email format']
}

Performance Matters

Unlike many validation libraries, Snap Validate is built for speed:

• Zero dependencies - No external packages to slow down installation

• Optimized algorithms - Efficient regex patterns and validation logic

• Minimal footprint - Small bundle size for faster loading

• Memory efficient - Smart caching and minimal object creation

Browser Support

Works seamlessly in both Node.js and browsers:

<script src="https://unpkg.com/snap-validate/src/index.js"></script>
<script>
  const { validators } = SnapValidate;

  const result = validators.email('user@example.com').validate();
  console.log(result.isValid);
</script>

When to Use Snap Validate

Snap Validate is perfect for:

• Form validation in web applications

• API input validation on the server

• Data sanitization before database operations

• Quick prototyping where you need validation fast

• Performance-critical applications where every millisecond counts

Conclusion

Snap Validate proves that you don't need heavy dependencies to get powerful validation. With its zero-dependency architecture, built-in security features, and intuitive API, it's the perfect choice for developers who want fast, reliable validation without the bloat.

Whether you're building a simple contact form or a complex enterprise application, Snap Validate has you covered with its comprehensive set of validators and flexible customization options.

Try It Out

Ready to give it a try? Install Snap Validate today:

npm install snap-validate

Check out the full documentation and examples on GitHub or NPM.

---

Have you used Snap Validate in your projects? Share your experience in the comments below!