valchecker

🔗

Composable Step Pipeline

Chain built-in validation steps or create custom plugins. Each step can validate, transform, or handle failures—all with the same ergonomic API.

🎯

Full Type Inference

Schemas stay synchronized with TypeScript types through transforms, narrowing checks, and fallback chains. No manual type assertions needed.

📋

Deterministic Issue Reporting

Every validation failure produces structured issues with codes, payloads, and deep paths—perfect for form validation or API error responses.

🌳

Tree-Shakable by Design

Import all steps with `allSteps` for rapid prototyping, or cherry-pick only what you need for production bundles that stay lean.

⚡

Async-Safe Pipelines

Mix synchronous and asynchronous steps freely. Database checks, API calls, and pure validation all flow through the same deterministic pipeline.

🔧

Batteries-Included Transforms

Trim strings, parse JSON, filter arrays, and normalize data inline—no need to scatter preprocessing logic across your codebase.

See It In Action

Define schemas with intuitive, chainable methods. Get full TypeScript inference automatically.

typescript

import { v } from 'valchecker'

// Define a user schema with composable steps
const UserSchema = v.object({
	name: v.string()
		.toTrimmed()
		.min(1),
	email: v.string(),
	age: [v.number()
		.integer()
		.min(0)], // Optional
	role: v.union([v.literal('admin'), v.literal('user'), v.literal('guest')]),
})

// Full type inference - no manual types needed
type User = InferOutput<typeof UserSchema>

// Validate with detailed issue reporting
const result = await UserSchema.execute(input)

if ('value' in result) {
	console.log(result.value) // Fully typed User
}
else {
	console.log(result.issues) // Structured issues with paths
}

Why Valchecker?

Unlike validation libraries that treat runtime and compile-time as separate concerns, Valchecker unifies them. Every schema is both a runtime validator and a TypeScript type generator. Transforms update types automatically. Failures produce predictable, structured issues—not thrown exceptions. The result is validation code that's easier to write, test, and maintain.

valcheckerRuntime-first validation with zero guesswork