Smart Data Validator

A powerful and flexible data validation library for JavaScript/TypeScript applications with support for:

• Nested object validation
• Async validation rules
• Custom validation rules
• Type checking
• Detailed error reporting
• TypeScript support

Installation

npm install smart-data-validator

Usage

import { SmartValidator, rules } from 'smart-data-validator';

// Define your validation schema
const schema = {
  username: {
    type: 'string',
    required: true,
    rules: [
      rules.minLength(3),
      rules.maxLength(20),
      rules.matches(/^[a-zA-Z0-9_]+$/, 'Username can only contain letters, numbers, and underscores')
    ]
  },
  email: {
    type: 'string',
    required: true,
    rules: [rules.email()]
  },
  age: {
    type: 'number',
    rules: [
      rules.min(18),
      rules.max(100)
    ]
  },
  website: {
    type: 'string',
    rules: [rules.url()]
  },
  address: {
    type: 'object',
    nested: {
      street: { type: 'string', required: true },
      city: { type: 'string', required: true },
      zipCode: { 
        type: 'string',
        rules: [rules.matches(/^\d{5}$/, 'Invalid ZIP code')]
      }
    }
  }
};

// Create validator instance
const validator = new SmartValidator(schema);

// Validate data
const data = {
  username: 'john_doe',
  email: 'invalid-email',
  age: 15,
  website: 'not-a-url',
  address: {
    street: '123 Main St',
    city: 'New York',
    zipCode: '12345'
  }
};

async function validateData() {
  const result = await validator.validate(data);
  console.log(result);
  // {
  //   isValid: false,
  //   errors: [
  //     { field: 'email', message: 'Invalid email address' },
  //     { field: 'age', message: 'Must be at least 18' },
  //     { field: 'website', message: 'Invalid URL' }
  //   ]
  // }
}

// Async validation example
const asyncSchema = {
  username: {
    type: 'string',
    rules: [
      rules.custom(
        async (value) => {
          // Simulate API call to check username availability
          const response = await fetch(\`/api/check-username/\${value}\`);
          return response.ok;
        },
        'Username already taken',
        true // mark as async
      )
    ]
  }
};

Built-in Rules

• email() - Validates email addresses
• minLength(min) - Validates minimum string length
• maxLength(max) - Validates maximum string length
• matches(regex, message?) - Validates against a regular expression
• min(min) - Validates minimum number value
• max(max) - Validates maximum number value
• url() - Validates URLs
• unique(array) - Validates value uniqueness
• custom(validator, message, isAsync?) - Creates custom validation rules

Creating Custom Rules

import { ValidationRule } from 'smart-data-validator';

const passwordStrength: ValidationRule<string> = {
  validator: (value) => {
    const hasUpperCase = /[A-Z]/.test(value);
    const hasLowerCase = /[a-z]/.test(value);
    const hasNumbers = /\d/.test(value);
    const hasSpecialChar = /[!@#$%^&*]/.test(value);
    return hasUpperCase && hasLowerCase && hasNumbers && hasSpecialChar;
  },
  message: 'Password must contain uppercase, lowercase, numbers, and special characters'
};

const schema = {
  password: {
    type: 'string',
    required: true,
    rules: [
      rules.minLength(8),
      passwordStrength
    ]
  }
};

License

MIT