Valita

A typesafe validation & parsing library for TypeScript.

ValidationTypes
badrap/valita@badrap/valita

README

@badrap/valita


A TypeScript library for validating & parsing structured objects. The API is _heavily_ influenced by Zod's excellent API, while the implementation side aims for the impressive performance of simple-runtypes.

We also pay special attention for providing descriptive validation error messages:

  1. ```ts
  2. const vehicle = v.union(
  3.   v.object({ type: v.literal("plane"), airline: v.string() }),
  4.   v.object({ type: v.literal("train") }),
  5.   v.object({ type: v.literal("automobile"), make: v.string() })
  6. );
  7. vehicle.parse({ type: "bike" });
  8. // ValitaError: invalid_literal at .type (expected "plane", "train" or "automobile")
  9. ```

Installation


For Node.js


  1. ```sh
  2. npm i @badrap/valita
  3. ```

For Deno


  1. ```ts
  2. import * as v from "https://deno.land/x/valita/mod.ts";
  3. ```

Docs aren't my forté


A motivating example in lack of any better documentation:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const Pet = v.object({
  5.   type: v.union(v.literal("dog"), v.literal("cat")),
  6.   name: v.string(),
  7. });

  9. const Person = v.object({
  10.   name: v.string(),
  11.   age: v.number(),
  12.   pets: v.array(Pet).optional(),
  13. });
  14. ```

Now Person.parse(value) returns value if it matches the Person schema - or throws an error otherwise.

  1. ```ts
  2. const grizzlor = Person.parse({
  3.   name: "Grizzlor",
  4.   age: 101,
  5.   pets: [
  6.     { type: "cat", name: "Mittens" },
  7.     { type: "cat", name: "Parsley" },
  8.     { type: "cat", name: "Lulu" },
  9.     { type: "cat", name: "Thomas Percival Meowther III" },
  10.   ],
  11. });
  12. ```

The real magic here comes from TypeScript's type inference. The inferred type for grizzlor is:

  1. ```ts
  2. const grizzlor: {
  3.   name: string;
  4.   age: number;
  5.   pets?: { type: "dog" | "cat"; name: string }[] | undefined;
  6. };
  7. ```

You can use `Infer` to get your mitts on the inferred type in your code:

  1. ```ts
  2. type PersonType = v.Infer<typeof Person>;
  3. ```

API Reference


This section contains an overview of all validation methods.

Primitive Types


Let's start with the basics! Like every validation library we support all primitive types like strings, numbers, booleans, null, undefined and more.

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const developer = v.object({
  5.   name: v.string(),
  6.   age: v.number(),
  7.   usesValita: v.boolean(),
  8.   projects: v.array(v.string()),
  9.   null: v.null(),
  10.   undefined: v.undefined(),
  11.   bigNumber: v.bigint(),
  12. });
  13. ```

On top of that we support additional methods to coerce specific values to a certain TypeScript type:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const something = v.object({
  5.   shouldNotHappen: v.never(),
  6.   noClueWhatThisIs: v.unknown(),
  7. });
  8. ```

Nullable Type


When working with APIs/DBs some types are nullable. Valita can validate those types via the .nullable() method:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. // type name = null | string
  5. const name = v.string().nullable();

  7. // Passes
  8. name.parse("Jane Doe");
  9. // Passes
  10. name.parse(null);
  11. ```

Optional Object Properties


One common occurrence when working with APIs is that some fields in an object are optional and therefore can be missing completely. Valita can skip validating those via the .optional() method:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const person = v.object({
  5.   name: v.string(),
  6.   // Not everyone filled in their favorite song
  7.   song: v.string().optional(),
  8. });

  10. // Passes
  11. person.parse({ name: "Jane Doe", song: "Never gonna give you up" });
  12. // Passes
  13. person.parse({ name: "Jane Doe" });
  14. ```

Record Type


Whereas .object() can be used to validate objects, it has the limitation that all property keys have to be known upfront. It doesn't support an arbitrary number of properties, which is where Record types come to the rescue.

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. // Every property key must be known upfront
  5. const obj = v.object({
  6.   foo: v.number(),
  7.   bar: v.number(),
  8. });

  10. // ...with records
  11. const obj2 = v.record(v.number());
  12. ```

With the record type you're essentially specifying that there are (theoretically) an infinite number of property keys which are all of type string. The argument you pass to .record() is the type of the property values. In the example above all property values are numbers.

Tuple Types


Despite JavaScript not having tuple values (yet?), many APIs leverage plain arrays as an escape hatch. For example: If we encode a range between two numbers we'd likely choose type Range = [number, number] as the data type. From JavaScript's point of view it's just an array but TypeScript knows about the value of each position and that the array must have two entries.

We can express the same with valita:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const range = v.tuple([v.number(), v.number()]);

  6. // Passes
  7. range.parse([1, 2]);
  8. range.parse([200, 2]);

  10. // Fails
  11. range.parse([1]);
  12. range.parse([1, 2, 3]);
  13. range.parse([1, "2"]);
  14. ```

Union Types


A union type is a value which can have several different representations. Let's imagine we have a value of type Shape that can be either a circle, a square or a rectangle.

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const rectangle = v.object({ type: "rectangle" });
  5. const square = v.object({ type: "square" });
  6. const circle = v.object({ type: "circle" });

  8. // Validates either as "rectangle", "square" or "circle"
  9. const shape = v.union(rectangle, square, circle);
  10. ```

Note that although in this example all representations have a shared property type, it's not necessary at all. Each representation can be completely different:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const primitive = v.union(v.number(), v.string(), v.boolean());
  5. ```

Literal Types


Sometimes knowing if a value is of a certain type is not enough. We can use the .literal() method to check for actual values, like checking if a string is either "red", "green" or "blue" and not just any string.

  1. ```js
  2. import * as v from "@badrap/valita";

  4. const rgb = v.union(v.literal("red"), v.literal("green"), v.literal("blue"));
  5. ```

We can also use this to check for concrete numbers, bigint literals or boolean values too:

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const banana2YearsOld = v.object({
  5.   kind: v.literal("banana"),
  6.   age: v.literal(2),
  7.   isFresh: v.literal(true),
  8. });
  9. ```

For more complex values you can use the .assert()-method. Check out the Custom validation functions to learn more about it.

Custom validation functions


The .assert()-method can be used for custom validation logic like verifying that a number is inside a certain range for example.

  1. ```js
  2. import * as v from "@badrap/valita";

  4. const schema = v
  5.   .number()
  6.   .assert((v) => v >= 0 && v <= 255, "Must be in between 0 or 255");
  7. ```

Composing custom validation functions


A core strength of valita is that validation functions are composable by nature. This means that you can reuse bits and pieces of your schema and compose schemas from smaller building blocks.

  1. ```js
  2. import * as v from "@badrap/valita";

  4. // Reusable custom schema for a Person type
  5. const personSchema = v
  6.   .object({
  7.     name: v.string()
  8.     age: v.number(),
  9.   })

  11. // Reuse the custom schema times
  12. const schema = v.object({
  13.   person: personSchema,
  14.   otherPerson: personSchema,
  15. });
  16. ```

Custom validations with type casting


Whilst the .assert()-method is very powerful to check if a type is valid or not, it can only return a boolean value. But sometimes we want to parse our data into a propert type in one go. Imagine a JSON-API which serializes dates as a string type representing a unix timestamp and we want to return a valid Date in our validation schema.

  1. ```json
  2. {
  3.   "created_at": "2022-01-01T00:00:00.000+00:00"
  4. }
  5. ```

This can be done with the .chain()-method which allows you to cast to a certain type on top of validating the value. It's a more general alternative to .assert() so to say.

The .chain()-method receives a function to which it will pass the raw value as the first argument. If the value is deemed as being incorrect we return an error message via v.err("My message"). If not we cast it to the type we want and pass that to v.ok(value).

Similar to .assert() the .chain()-method must follow a preceding validation function like v.string() in our example.

  1. ```js
  2. import * as v from "@badrap/valita";

  4. const dateSchema = v.string().chain((str) => {
  5.   const date = new Date(str);

  7.   // If the date is invalid JS returns NaN here
  8.   if (isNaN(date.getTime())) {
  9.     return v.err(`Invalid date "${str}"`);
  10.   }

  12.   return v.ok(date);
  13. });

  15. const schema = v.object({
  16.   created_at: dateSchema,
  17. });
  18. ```

Recursive Types


One strong suit of valita is its ability to parse types that references itself, like type T = string | T[]. We can express such a shape with valita using the .lazy() method.

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. type T = string | T[];
  5. const myType: v.Type<T> = v.lazy(() => v.union(v.string(), v.array(myType)));
  6. ```

_Note that TypeScript needs an explicit type cast as it cannot interfere return types of recursive functions. That's why the variable is typed as `v.Type`._

Validating Self-Referencing Schemas


You may come across a schema where fields are related to each other and need to be validated together. Let's pick an example where a JSON-API returns an object with a min and max property. In our schema we want to ensure that the min value is smaller than max.

  1. ```json
  2. {
  3.   "min": 10,
  4.   "max": 100
  5. }
  6. ```

For that we assert that both properties are of type number via the .number()-method. To be able to compare them to each other we add a validation helper on the common parent type of the fields we want to compare. We can leverage the .assert()-method on the surrounding .object() result in our example.

  1. ```ts
  2. import * as v from "@badrap/valita";

  4. const schema = v
  5.   .object({
  6.     min: v.number(),
  7.     max: v.number(),
  8.   })
  9.   .assert((obj) => obj.min < obj.max, ".min must be smaller than .max");
  10. ```

License


This library is licensed under the MIT license. See LICENSE.