Zod Express validator

A part of Zodyac project.

This package provides a set of usefull Express tools for REST request validation with zod (body, parameters and query) based on Matt Pocock's (💜) solution.

Installation

As simple as:

1npm i @zodyac/express

Usage

Validating body

Define your request body schema:

1import { z } from 'zod';
2
3const zBody = z.object({
4  // ... your zod schema
5});

Create an endpoint using CheckBody function:

1const my_endpoint = CheckBody(zBody, (req, res) => {
2  const body = req.body;
3  // ... the rest of your code
4});

Validating parameters

You can also parse your request parameters using CheckParams:

1const my_endpoint = CheckParams(zParams, (req, res) => {
2  const params = req.params;
3  // ... the rest of your code
4});

Validating query parameters

And query parameters using CheckQuery:

1const my_endpoint = CheckQuery(zQuery, (req, res) => {
2  const query = req.query;
3  // ... the rest of your code
4});

As you can see, req.body, req.params and req.query are inferring types from your zod schema.

Please remember that Express params and query parameters are always strings. If you want to parse them to other types, you have to do it manually.

Validating all at once

But what if... We want to validate all of them at once? No problem, just use Check:

1const my_endpoint = Check({
2  body: zBody,
3  params: zParams,
4  query: zQuery
5}, (req, res) => {
6  const body = req.body;
7  const params = req.params;
8  const query = req.query;
9  // ... the rest of your code
10});

Error handling

If validation fails, Check, CheckBody, CheckParams and CheckQuery will automatically send 406 response with error message. If you want to handle errors yourself, you can use ValidationOptions:

1const my_error_handler: ze.ValidationOptions = {
2  errorCode: 400, // default is 406 (Not Acceptable)
3  errorHandler: (req, res, error) => { // error is zod Error
4    const error_message = error.errors[0].message;
5    // ... your error handling code
6  }
7};
8
9const my_endpoint = Check({
10  body: zBody,
11  params: zParams,
12  query: zQuery
13}, (req, res) => {
14  const body = req.body;
15  const params = req.params;
16  const query = req.query;
17  // ... the rest of your code
18}, my_error_handler);

ValidationOptions interface:

1type ErrorHandler = (req: Request, res: Response, error: z.ZodError) => void;
2
3interface ValidationOptions {
4  errorCode?: number;
5  errorHandler?: ErrorHandler;
6}

Middleware

If you prefer to validate your requests aside from your endpoints logic, you can use zem.Body, zem.Params, zem.Query or zem.Check middleware:

1import { zem } from '@zodyac/express';
2
3const my_endpoint = (req: Request, res: Response) => {
4  const body = req.body;
5  const params = req.params;
6  const query = req.query;
7  // ... the rest of your code
8};
9
10app.post('/my_endpoint', zem.Body(zBody), my_endpoint);
11app.get('/my_endpoint/:id', zem.Params(zParams), my_endpoint);
12app.get('/my_endpoint', zem.Query(zQuery), my_endpoint);
13
14app.put('/my_endpoint', zem.Check({
15  body: zBody,
16  params: zParams,
17  query: zQuery
18}), my_endpoint);

In this case your req.body, req.params and req.query will be any. If you want to use types, you have to specify them manually or use CheckBody, CheckParams, CheckQuery or Check.

Experimental: decorators

You can also use decorators to validate your requests. Just add @ValidateBody, @ValidateParams, @ValidateQuery or @Validate to your endpoint function:

1export class Example {
2
3  @ValidateBody(zBody)
4  public static my_endpoint(req: Request, res: Response) {
5    const body = req.body as z.infer<typeof zBody>;
6    // ... the rest of your code
7  }
8
9}

Due to the limitations of TypeScript decorators, you have to specify the type of req.body manually.

License

MIT