Introducing IsoValid: A Lightweight Isomorphic Data Validation Library

🚀 Why Data Validation Matters

Data validation is a crucial part of modern web applications, ensuring data integrity, security, and a smooth user experience. However, developers often struggle with:

• Writing separate validation logic for frontend and backend
• Managing multiple validation libraries across environments
• Keeping validation consistent between client and server

Introducing IsoValid—a powerful, isomorphic validation library that allows you to use the same validation logic across both browser and Node.js environments.

🔥 What is IsoValid?

IsoValid is a lightweight, TypeScript-first validation library designed to unify validation across your entire application stack. Whether you're validating user input in a React form or ensuring API request integrity in an Express server, IsoValid makes it seamless.

🌟 Key Features

✅ True Isomorphic Support – The same validation code runs in both frontend and backend ✅ TypeScript-First – Fully typed API for strong type inference ✅ Minimal Bundle Size – No unnecessary dependencies or bloat ✅ Intuitive API – Developer-friendly, chainable syntax ✅ High Performance – Optimized validation with minimal overhead ✅ Extensible – Easily add custom validators and error messages

📦 Installation

Get started with IsoValid in seconds:

npm install isovalid

🔹 Core Architecture

IsoValid is built on a flexible, extensible architecture that includes:

Base Schema Class

• Foundation for all validation schemas
• Handles optional/nullable states
• Common validation logic across types

Type-Specific Schemas

• StringSchema – Length, regex, email, trimming, etc.
• NumberSchema – Min/max, integer, positive/negative checks
• More types coming soon (Boolean, Array, Object)

Validation Pipeline

• Multi-stage validation process
• Supports custom validation functions
• Returns detailed error reporting

⚡ Usage Examples

String Validation

import { v } from 'isovalid';

const stringSchema = v.string() .min(2) // Minimum length .max(50) // Maximum length .email() // Must be a valid email .matches(/regex/) // Custom pattern .trimmed() // Remove extra whitespace .setOptional() // Allow undefined .setNullable(); // Allow null

Number Validation

const numberSchema = v.number() .min(0) // Minimum value .max(100) // Maximum value .integer() // Must be an integer .positive(); // Must be > 0

Validation Results

interface ValidationResult { valid: boolean; errors: Array<{ path: string[]; message: string; }>; }

🎯 Real-World Examples

1. React Form Validation

import { v } from 'isovalid'; import { useState, FormEvent } from 'react';

const userSchema = { username: v.string().min(3).max(20), email: v.string().email(), age: v.number().integer().min(18) };

function RegistrationForm() { const [formData, setFormData] = useState({ username: '', email: '', age: '' }); const [errors, setErrors] = useState<Record<string, string>>({});

const validateField = (field: keyof typeof userSchema, value: any) => { const result = userSchema[field].validate(value); return result.valid ? null : result.errors[0].message; };

const handleSubmit = (e: FormEvent) => { e.preventDefault(); const newErrors: Record<string, string> = {};

Object.entries(formData).forEach(([field, value]) => { const error = validateField(field as keyof typeof userSchema, value); if (error) newErrors[field] = error; });

if (Object.keys(newErrors).length === 0) { console.log('Submitting:', formData); } else { setErrors(newErrors); } };

return ( <form onSubmit={handleSubmit}> <input type="text" placeholder="Username" onChange={e => setFormData(prev => ({ ...prev, username: e.target.value }))} /> {errors.username && <span>{errors.username}</span>} <button type="submit">Register</button> </form> ); }

2. Express API Validation

import express from 'express'; import { v } from 'isovalid';

const app = express(); app.use(express.json());

const productSchema = { name: v.string().min(3).max(100), price: v.number().min(0), category: v.string().custom(value => ['electronics', 'books', 'clothing'].includes(value) ? null : 'Invalid category' ) };

app.post('/api/products', (req, res) => { const errors = Object.entries(productSchema) .map(([field, schema]) => ({ field, result: schema.validate(req.body[field]) })) .filter(({ result }) => !result.valid) .map(({ field, result }) => ({ field, message: result.errors[0].message }));

if (errors.length > 0) { return res.status(400).json({ errors }); }

res.status(201).json(req.body); });

🎯 Best Practices

✅ Schema Reuse – Define schemas once & share across frontend/backend ✅ Type Safety – Leverage TypeScript’s inference capabilities ✅ Performance Optimization – Cache schema instances for reuse ✅ Error Handling – Always check .valid before using data

🛠️ Roadmap

🚀 Upcoming Features:

-

📌 Get Started with IsoValid

IsoValid is open-source and welcomes contributions! Try it today and share your feedback.

🔗 NPM Package: IsoValid on NPM 🔗 GitHub Repository: GitHub Repo

Let’s make data validation simpler together! 🚀