tiny-validate

v1.0.1

Published

5 months ago

A Super Lightweight, Chainable Data Validation Module

0High
0Medium
0Low

mr_dark

validate tiny-validate micro-validate

tiny-validate - Simple JavaScript Validator

A lightweight, chainable, and comprehensive data validation library for JavaScript.

Features

Chainable API: Easily apply multiple validation rules in a single, readable line of code.
Rich Rule Set: Includes a wide range of validation rules for strings, numbers, arrays, dates, and more.
Clear Error Handling: Returns a detailed object with all validation errors, including the rule that failed and a descriptive message.
Customizable: Override default error messages with your own for tailored feedback.

Installation

npm install tiny-validate

Usage

Import the Module First, import the createValidator factory function.

const { createValidator } = require('./index.js');

Basic Validation Use createValidator to start a validation chain for a specific value and field name.

const user = {
  name: 'John',
  email: '[email protected]',
  age: 30
};

// Validate the 'name' field
const nameResult = createValidator('name', user.name)
  .isNotEmpty('Name cannot be empty.')
  .isString('Name must be a string.')
  .minLength(2, 'Name must be at least 2 characters long.')
  .validate();

console.log(nameResult);
/*
Output:
{
  isValid: true,
  errors: [],
  value: 'John'
}
*/

Handling Validation Failures The validate() method returns an object with an isValid boolean and an errors array.

const user = {
  name: 'A',
  email: 'invalid-email',
  age: 17
};

const validationResult = createValidator('user data', user)
  .hasKey('name', 'User object must have a name.')
  .hasKey('email')
  .hasKey('age')
  .validate();

const emailResult = createValidator('email', user.email)
  .isEmail('Please enter a valid email address.')
  .validate();

const ageResult = createValidator('age', user.age)
  .isNumber('Age must be a number.')
  .min(18, 'You must be at least 18 years old.')
  .validate();

console.log('User Validation:', validationResult);
console.log('Email Validation:', emailResult);
console.log('Age Validation:', ageResult);

/*
Example Output:
User Validation: {
  isValid: true,
  errors: [],
  value: { name: 'A', email: 'invalid-email', age: 17 }
}
Email Validation: {
  isValid: false,
  errors: [
    { rule: 'matches', message: 'Please enter a valid email address.' }
  ],
  value: 'invalid-email'
}
Age Validation: {
  isValid: false,
  errors: [
    { rule: 'min(18)', message: 'You must be at least 18 years old.' }
  ],
  value: 17
}
*/

Array Validation with .each() The .each() method is powerful for validating every item in an array.

const numbers = [1, 2, 'three', 4, 5];

const arrayResult = createValidator('numbers', numbers)
  .isArray('Value must be an array.')
  .each(item => createValidator('item', item).isInteger('All items must be integers.'))
  .validate();

console.log(arrayResult);
/*
Output:
{
  isValid: false,
  errors: [
    {
      rule: 'each',
      message: 'An item in the array failed validation: [{"rule":"isInteger","message":"All items must be integers."}]'
    }
  ],
  value: [1, 2, 'three', 4, 5]
}
*/

JavaScript Best Practices This module is written to adhere to several key JavaScript best practices.

Immutability The validator object is designed to be immutable. Each method call returns a new instance of the validator with the updated state, ensuring that the original object remains unchanged.
Functional Programming The .each() method is a great example of functional programming principles. It accepts a function as an argument, allowing you to apply any validation logic to each element of an array, promoting reusable and modular code.
Clear Naming Conventions All methods and variables use clear, descriptive names (e.g., isNotEmpty, minLength, fieldName). This makes the code self-documenting and easy to understand at a glance.
Modularity (ES Modules) The module.exports = { createValidator } syntax follows the Node.js standard for exporting modules. This makes the code reusable and easy to integrate into larger projects.
Defensive Programming The check() method is a core example of defensive programming. It encapsulates the core logic of a validation rule, ensuring that a consistent error is added to the errors array if a condition is not met.
Code Style and Readability The code is well-formatted with consistent indentation and uses modern syntax (e.g., const and let), making it clean and readable.

Pkg
Stats

Discover Tips

General search

Package details

User packages

Sponsor

About

Twitter

GitHub

Twitter

GitHub

Site

Open Software & Tools

Framework

Server

Data Store

Caching

CSS / Styling

Typeface

Avatars

Data Viz

Date formatting

Infinite scrolling

Markdown rendering

Repository url parsing

User data

Compiling

Types

Odds & Ends

tiny-validate

v1.0.1

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

tiny-validate - Simple JavaScript Validator

Features

Installation