Common

All schemas contain some common methods.

Methods

parse

The parse method takes a value parameter as input. If the value conforms to the schema, then the parsed value is returned with the appropriate type, otherwise an exception containing a messages method is thrown. See the messages reference for details.

import * as p from '@vbudovski/paseri';

const schema = p.string();
try {
    const parsedValue = schema.parse('foo');
    // Do something with the `string`.
} catch (e) {
    // Do something with the exception.
}

safeParse

The safeParse method takes a value parameter as input. The result is a discriminated union with a boolean member ok. You can use it to extract the parsed value on success or get the error messages using result.messages().

import * as p from '@vbudovski/paseri';

const schema = p.string();
const result = schema.safeParse('foo');
if (result.ok) {
    // Do something with the `result.value`.
} else {
    // Do something with the `result.messages()`.
}

optional

Allow any schema to accept undefined as a valid value.

import * as p from '@vbudovski/paseri';

const schema = p.string().optional();
const result = schema.safeParse(undefined)
if (result.ok) {
    // result.value is of type `string | undefined`.
}

nullable

Allow any schema to accept null as a valid value.

import * as p from '@vbudovski/paseri';

const schema = p.string().nullable();
const result = schema.safeParse(null)
if (result.ok) {
    // result.value is of type `string | null`.
}

chain

Chain schemas to convert data types. The chain method takes the target schema as the first argument, and a transformer function as the second argument.

Caution

The transformer function must not throw! Instead, return an error code using the err helper function.

import * as p from '@vbudovski/paseri';

const schema = p.string().chain(p.bigint(), (value) => {
    try {
        return p.ok(BigInt(value));
    } catch {
        return p.err('invalid_bigint');
    }
});
// Number.MAX_SAFE_INTEGER + 1 as a string.
const result = schema.safeParse('9007199254740992')
if (result.ok) {
    // result.value is of type `bigint`.
}

Types

Infer

You can use the Infer type to determine the result type of any schema. This is useful, because you don’t want to manually define a type that could easily get out of sync with the schema definition.

import * as p from '@vbudovski/paseri';

const schema = p.object({
    foo: p.string(),
    bar: p.number(),
})

type MySchema = p.Infer<typeof schema>;
// MySchema will be { foo: string, bar: number }.