Function argument validation for humans

Why use Ow?

TypeScript only validates types at compile time. Once compiled, your program can still receive unexpected data at runtime from:

Function arguments receiving untrusted input
CLI arguments and flags
Environment variables and configuration files

For complex schema validation (API responses, database queries, JSON parsing), use zod instead.

Ow provides runtime validation that:

Catches errors early - Fail fast with descriptive error messages instead of cryptic runtime errors
Documents expectations - Make your code self-documenting by explicitly stating what you expect
Simplifies debugging - Spend less time tracking down type-related bugs in production
Works anywhere - Use the same validation on the server, in the browser, or in CLI tools
Provides type guards - Narrow TypeScript types for safer code after validation

Highlights

Expressive chainable API
Lots of built-in validations
Supports custom validations
Automatic label inference in Node.js
Written in TypeScript

Install

npm install ow

Usage

import ow from 'ow';

const unicorn = input => {
	ow(input, ow.string.minLength(5));

	// …
};

unicorn(3);
//=> ArgumentError: Expected `input` to be of type `string` but received type `number`

unicorn('yo');
//=> ArgumentError: Expected string `input` to have a minimum length of `5`, got `yo`

Practical Examples

Function Arguments

import ow from 'ow';

const resize = (width: unknown, height: unknown) => {
	ow(width, 'width', ow.number.positive.integer);
	ow(height, 'height', ow.number.positive.integer);
	
	// Process the image...
};

resize(640, 480); // ✓
resize(-100, 200); // ✗ ArgumentError: Expected `width` to be a positive number
resize(640, "480"); // ✗ ArgumentError: Expected `height` to be of type `number`

Configuration Validation

import ow from 'ow';

const config = {
	port: process.env.PORT,
	apiKey: process.env.API_KEY,
	nodeEnv: process.env.NODE_ENV
};

// Validate configuration at startup
ow(config.port, ow.string.numeric);
ow(config.apiKey, ow.string.minLength(32));
ow(config.nodeEnv, ow.string.oneOf(['development', 'production', 'test']));

// Your app won't start with invalid configuration
const port = parseInt(config.port, 10);

Constructor Validation

import ow from 'ow';

class User {
	constructor(name: string, email: string, age?: number) {
		ow(name, ow.string.nonEmpty);
		ow(email, ow.string.email);
		ow(age, ow.optional.number.integer.positive.lessThanOrEqual(120));
		
		this.name = name;
		this.email = email;
		this.age = age;
	}
}

new User('Jane', 'jane@example.com', 25); // ✓
new User('', 'jane@example.com'); // ✗ ArgumentError: Expected string to not be empty

Utility Functions

import ow from 'ow';

const delay = (milliseconds: unknown) => {
	ow(milliseconds, ow.number.positive.integer);
	return new Promise(resolve => setTimeout(resolve, milliseconds));
};

const getRandomInteger = (min: number, max: number) => {
	ow(min, ow.number.integer);
	ow(max, ow.number.integer.greaterThanOrEqual(min));
	return Math.floor(Math.random() * (max - min + 1)) + min;
};

CLI Arguments

import ow from 'ow';

const cli = (arguments_: string[]) => {
	const [command, ...options] = arguments_;
	
	ow(command, ow.string.oneOf(['build', 'test', 'deploy']));
	
	if (command === 'deploy') {
		const [environment] = options;
		ow(environment, ow.string.oneOf(['staging', 'production']));
	}
	
	// Proceed with validated command
};

[!NOTE] If you intend on using ow for development purposes only, use import ow from 'ow/dev-only' instead of the usual import ow from 'ow', and run the bundler with NODE_ENV set to production (e.g. $ NODE_ENV="production" parcel build index.js). This will make ow automatically export a shim when running in production, which should result in a significantly lower bundle size.

API

Complete API documentation

Ow includes TypeScript type guards, so using it will narrow the type of previously-unknown values.

function (input: unknown) {
	input.slice(0, 3) // Error, Property 'slice' does not exist on type 'unknown'

	ow(input, ow.string)

	input.slice(0, 3) // OK
}

ow(value, predicate)

Test if value matches the provided predicate. Throws an ArgumentError if the test fails.

ow(value, label, predicate)

Test if value matches the provided predicate. Throws an ArgumentError with the specified label if the test fails.

The label is automatically inferred in Node.js but you can override it by passing in a value for label. The automatic label inference doesn't work in the browser.

ow.isValid(value, predicate)

Returns true if the value matches the predicate, otherwise returns false.

ow.validate(value, predicate)

Validate a value against a predicate without throwing. Returns a result object with type narrowing.

import ow, {type ValidateResult} from 'ow';

const result = ow.validate(value, ow.string);

if (!result.success) {
	console.error(result.error.message);
	return;
}

// result.value is now typed as string
console.log(result.value.length);

The return type is a discriminated union:

type ValidateResult<T> =
	| {success: true; value: T}
	| {success: false; error: ArgumentError};

This allows TypeScript to narrow the type based on the success property. When success is true, you can access value. When success is false, you can access error.

ow.validate(value, label, predicate)

Validate a value against a predicate with a custom label without throwing.

const result = ow.validate(username, 'username', ow.string.minLength(3));

if (!result.success) {
	console.error(result.error.message);
	//=> Expected string `username` to have a minimum length of `3`, got `ab`
}

ow.isPredicate(value)

Test if the provided value is an Ow predicate.

Useful for building higher-order functions that need to distinguish between predicates and other values.

ow.create(predicate)

Create a reusable validator.

const checkPassword = ow.create(ow.string.minLength(6));

const password = 'foo';

checkPassword(password);
//=> ArgumentError: Expected string `password` to have a minimum length of `6`, got `foo`

ow.create(label, predicate)

Create a reusable validator with a specific label.

const checkPassword = ow.create('password', ow.string.minLength(6));

checkPassword('foo');
//=> ArgumentError: Expected string `password` to have a minimum length of `6`, got `foo`

ow.any(...predicate[])

Returns a predicate that verifies if the value matches at least one of the given predicates.

ow('foo', ow.any(ow.string.maxLength(3), ow.number));

ow.optional.{type}

Makes the predicate optional. An optional predicate means that it doesn't fail if the value is undefined.

ow(1, ow.optional.number);

ow(undefined, ow.optional.number);

ow.nullable.{type}

Makes the predicate nullable. A nullable predicate means that it doesn't fail if the value is null.

ow(1, ow.nullable.number);

ow(null, ow.nullable.number);

This is useful for validating inputs from external sources (like GraphQL APIs) that use null to represent absent values. We encourage using undefined over null in your own APIs, but recognize you can't control what external APIs return. See our recommendation against using null.

ow.absent.{type}

Marks properties in object shapes as absent, meaning the key can be completely missing from the object. This is different from optional which allows both missing keys AND undefined values.

type Hotdog = {
	length: number;
	topping: string;
};

function patchHotdog(hotdog: Hotdog, patchBody: unknown): Hotdog {
	ow(
		patchBody,
		ow.object.exactShape({
			length: ow.absent.number,
			topping: ow.absent.string,
		}),
	);

	return {
		...hotdog,
		...patchBody, // Type-safe object spreading
	};
}

const dog = {length: 10, topping: 'mustard'};

patchHotdog(dog, {length: 12}); // ✓ Partial update
patchHotdog(dog, {}); // ✓ Empty update
patchHotdog(dog, {length: 12, topping: 'ketchup'}); // ✓ Full update
patchHotdog(dog, {length: 'twelve'}); // ✗ Wrong type

This is particularly useful for:

Patch/update operations where missing keys mean "don't change"
Partial form submissions
Configuration merging where only specified keys should be overridden

Key differences from optional:

At runtime, both modifiers allow missing keys. The difference is in how they handle undefined values and type inference:

// optional: allows missing keys AND undefined values
// Type inference: { name: string | undefined }
ow({}, ow.object.exactShape({
	name: ow.optional.string // ✓ Valid - missing key
}));
ow({name: undefined}, ow.object.exactShape({
	name: ow.optional.string // ✓ Valid - undefined value
}));

// absent: allows missing keys but NOT undefined values
// Type inference: { name?: string }
ow({}, ow.object.exactShape({
	name: ow.absent.string // ✓ Valid - missing key
}));
ow({name: undefined}, ow.object.exactShape({
	name: ow.absent.string // ✗ Invalid - undefined not allowed
}));

The key distinction: use .absent when missing keys mean "don't change" (patch operations), and .optional when undefined is a valid value.

ow.{type}

All the below types return a predicate. Every predicate has some extra operators that you can use to test the value even more fine-grained.

Predicate docs.

Primitives

undefined
`nu

Ow

Install / Use

README