gem-hunter

Zod Validator for AdonisJS

// Instead of VineJS
const data = await request.validateUsing(vine.compile(vineSchema))

// Use Zod directly
const data = await request.validateUsing(zodSchema)

Installation

npm install @emorio/zod-validator zod

yarn add @emorio/zod-validator zod

pnpm add @emorio/zod-validator zod

Configuration

1. Register the Provider

import { defineConfig } from '@adonisjs/core/app'

export default defineConfig({
  // ... other config
  providers: [
    // ... other providers
    () => import('@emorio/zod-validator/zod_provider'),
  ],
})

Usage

Basic Validation

import { HttpContext } from '@adonisjs/core/http'
import { z } from 'zod'

// Define your Zod schema
const createUserSchema = z.object({
  username: z.string().min(3).max(50),
  email: z.email(),
  age: z.number().int().min(18),
})

export default class UsersController {
  async store({ request, response }: HttpContext) {
    try {
      // Validate request data
      const validatedData = await request.validateUsing(createUserSchema)

      console.log(validatedData.username) // TypeScript knows this is a string

      // Create user with validated data
      // ... your logic here

      return response.json({ message: 'User created successfully' })
    } catch (error) {
      return response.status(422).json({ errors: error.errors })
    }
  }
}

Advanced Validation with Headers and Params

import { HttpContext } from '@adonisjs/core/http'
import { z } from 'zod'

export default class PostsController {
  async update({ request, response }: HttpContext) {
    const updatePostSchema = z.object({
      // Request body validation
      title: z.string().min(1).max(255),
      content: z.string().min(10),
      published: z.boolean().optional(),

      // Route params validation
      params: z.object({
        id: z.string().uuid(),
      }),

      // Headers validation
      headers: z.object({
        'content-type': z.string(),
        'authorization': z.string().startsWith('Bearer '),
      }),

      // Cookies validation (optional)
      cookies: z
        .object({
          session_id: z.string().optional(),
        })
        .optional(),
    })

    const validatedData = await request.validateUsing(updatePostSchema)

    // Access validated data with full type safety
    const postId = validatedData.params.id
    const authToken = validatedData.headers.authorization
    const title = validatedData.title

    // ... your logic here
  }
}

API Reference

request.validateUsing<Schema>(schema: Schema): Promise<z.infer<Schema>>

Error Handling

Global Exception Handler

import { errors } from '@adonisjs/core'
import { HttpContext } from '@adonisjs/core/http'
import { ZodError } from 'zod'

export default class HttpExceptionHandler extends errors.HttpExceptionHandler {
  async handle(error: unknown, ctx: HttpContext) {
    if (error instanceof ZodError) {
      // z.treeifyError(error);
      // handle the error
    }

    return super.handle(error, ctx)
  }
}

Roadmap & Enhancements

Planned Features

Testing

npm test

Requirements

License

Credits