Validation API Reference

1import { createApp, z, validate } from '@morojs/moro';
2
3const app = createApp();
4
5// Chainable validation API (actual implementation)
6app.post('/users')
7  .body(z.object({
8    name: z.string().min(2).max(50),
9    email: z.string().email(),
10    age: z.number().min(18).optional()
11  }))
12  .handler((req, res) => {
13    // req.body is automatically validated and typed
14    const { name, email, age } = req.body;
15    return { success: true, data: { name, email, age } };
16  });
17
18// Query validation
19app.get('/users')
20  .query(z.object({
21    limit: z.coerce.number().min(1).max(100).default(10),
22    search: z.string().optional()
23  }))
24  .handler((req, res) => {
25    // req.query is validated and typed
26    const { limit, search } = req.query;
27    return { success: true, data: [], limit, search };
28  });
29
30// Using validate middleware (alternative approach)
31app.post('/users-alt', 
32  validate({
33    body: z.object({
34      name: z.string().min(2),
35      email: z.string().email()
36    })
37  }),
38  (req, res) => {
39    return { success: true, data: req.body };
40  }
41);
42
43// Schema-first route definition
44app.route({
45  method: 'GET',
46  path: '/users-schema',
47  validation: {
48    query: z.object({
49      limit: z.coerce.number().default(10),
50      search: z.string().optional()
51    })
52  },
53  handler: (req, res) => {
54    return { success: true, query: req.query };
55  }
56});

1app.post('/users', {
2  body: CreateUserSchema,
3  
4  // Custom validation error handler
5  onValidationError: (errors, context) => {
6    return {
7      status: 422,
8      body: {
9        error: 'VALIDATION_FAILED',
10        message: 'The request data is invalid',
11        timestamp: new Date().toISOString(),
12        path: context.request.url,
13        errors: errors.map(err => ({
14          field: err.path.join('.'),
15          value: err.input,
16          message: err.message,
17          code: err.code
18        }))
19      }
20    };
21  },
22  
23  handler: ({ body }) => {
24    return createUser(body);
25  }
26});

1const app = createApp({
2  validation: {
3    // Global error handler
4    onError: (errors, context) => ({
5      status: 400,
6      body: {
7        error: 'INVALID_REQUEST',
8        details: errors
9      }
10    }),
11    
12    // Validation options
13    abortEarly: false,        // Return all errors
14    stripUnknown: true,       // Remove unknown fields
15    allowUnknown: false       // Reject unknown fields
16  }
17});