nemo-zod-validators

@zanreal/nemo and zod saved my life when working with Next.js, but writing the same validation functions over and over was driving me crazy.

So, this just makes adding validation even easier.

Install

npm i @dozyhermit/nemo-zod-validators

Upgrade

[!WARNING] If you are using CommonJS, you may run into build problems after v3.0.1; consider supporting ESM in your project.

If your project uses older versions of @zanreal/nemo or zod, upgrade your project schemas and middleware first.

See:

• @zanreal/nemo: https://zanreal.com/docs/oss/nemo
• zod: https://zod.dev

When that's done, upgrade @dozyhermit/nemo-zod-validators to the latest version.

Usage

In your proxy.ts or middleware.ts Next.js project file:

import { createNEMO } from '@zanreal/nemo';
import { z } from 'zod';
import { validatePath } from '@dozyhermit/nemo-zod-validators';

const schema = z.object({
  world: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

const middlewares = {
  '/api/hello/:world': [validatePath<SchemaType>({ schema })],
};

// this will be "export const middleware" for middleware.ts files
export const proxy = createNEMO(middlewares);

Functions

validateGeneric

Validates data against a zod schema using safeParse. This is the base for all the schema based validators in this package.

The return type can be either Response or NextResponse.next().

Example

const schema = z.object({
  hello: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

validateGeneric<SchemaType>({ data: { hello: 'World' }, schema });

Creating Your Own Validator

This couldn't be simpler, but the only thing you have to remember is how to prevent validateGeneric from executing immediately.

For example, let's create a validateCustom validator:

type ValidateCustom = ValidateSchema;

export const validateCustom = <T>({ schema }: ValidateCustom) => {
  return async (request: NextRequest, _event: NemoEvent) =>
    validateGeneric<T>({
      data: request.body as T,
      schema,
    });
};

In the above, we return a function because when we use it like below:

const middlewares = {
  '/api/hello/world': [validateCustom<SchemaType>({ schema })],
};

it means validateGeneric is not immediately executed when the api starts; it will only ever run when we make a request to /api/hello/world.

validateBody

Validates the request.json() function inside a NextRequest request using zod.safeParse.

The return type can be either Response or NextResponse.next().

Example

const schema = z.object({
  hello: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

validateBody<SchemaType>({ schema });

validateCookies

Validates the request.cookies object inside a NextRequest request using zod.safeParse.

The return type can be either Response or NextResponse.next().

Example

const schema = z.object({
  hello: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

validateCookies<SchemaType>({ schema });

validateEquals

Validates a local variable against a variable inside a NextRequest request using the === operator.

The return type can be either Response or NextResponse.next().

Example

const value = process.env.MY_ENV_VAR;
const transform = (request) => request.headers.get('MY_HEADER');

validateEquals<string | null>({ value, transform });

validateHeaders

Validates the request.headers tuple inside a NextRequest request using zod.safeParse.

The return type can be either Response or NextResponse.next().

Example

const schema = z.object({
  hello: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

validateHeaders<SchemaType>({ schema });

validateParams

[!CAUTION] validateParams has been deprecated, please use validatePath instead.

validateParams and validatePath are exactly the same function, but it has been renamed to be more appropriate.

validatePath

Validates the params object provided by NemoEvent using zod.safeParse.

The return type can be either Response or NextResponse.next().

Example

const schema = z.object({
  hello: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

validatePath<SchemaType>({ schema });

validateQuery

Validates request.nextUrl.searchParams (URLSearchParams) inside a NextRequest request using zod.safeParse.

The return type can be either Response or NextResponse.next().

Example

const schema = z.object({
  hello: z.string().regex(/[0-9]+/, { error: 'Invalid string' }),
});

type SchemaType = z.infer<typeof Schema>;

validateQuery<SchemaType>({ schema });