Validating Requests

FW24 boasts a robust validation framework, offering two types of validation for API endpoints:

• InputValidationRule<{...some-type...}> allows for straightforward validations for any input or type.

      const myInputValidation: InputValidationRule<{a: string, b: string}> = {        a: {            required: true,            minLength: 5        },        b: {            required: true,            dataType: 'email'        }    }

• HttpRequestValidations offers validation rules for the entire HTTP request, including the body, header, param, and query.

      type Body = {        a: string,        b: string,    };
      type Param = {        id: string,    };
      type Header = {        'xxx-api-key': string,        'xxx-client-id': string,    };
      type Query = {        cursor: string,        sort: 'asc' | 'desc',    };
      const myHttpRequestValidations: HttpRequestValidations<Header, Body, Param, Query> = {        body: {            a: {                required: true,                maxLength: 100,            },            b: {                required: true,                inList: ['My Auth 1', 'My Auth 2'] // The author must be one of the two names            }        },        path: {            id: {                required: true,                dataType: 'uuid',            }        },        query: {            cursor: {                required: true,            },            sort: {                inList: ['asc', 'desc']            }        },        header: {            'xxx-api-key': {                eq: 'xxx-yyy-zzz'            },            'client-id': {                required: true            }        }    }

Implementing Validations for Routes

FW24 supports the addition of validation in method decorators and also offers a dedicated @Validations() decorator for those who prefer this approach..

Implementing Validation in the Method Decorator

For methods of type [POST, PATCH, PUT], the validations apply to the request body. For other types, they apply to the query parameters.

    type RequestInputSchema = {        bookName: string,        authorName: string,    };
    @Controller('demo')    export class MyController extends APIController {                @Get('/my-endpoint', {            validations: {                bookName: {                    required: true,                    maxLength: 100,                },                authorName: {                    required: true,                    inList: ['My Auth 1', 'My Auth 2'] // The author must be one of the two names                }            }        })        private myEndpointHandler(req: Request, res: Response): Promise<Response>{            const {bookName, authorName} = req.queryString as RequestInputSchema;            return res.json({bookName, authorName});        }
        @Post('/my-endpoint', {            validations: {                bookName: {                    required: true,                    maxLength: 100,                },                authorName: {                    required: true,                    inList: ['My Auth 1', 'My Auth 2'] // The author must be one of the two names                }            }        })        private myEndpointHandler(req: Request, res: Response): Promise<Response>{            const {bookName, authorName} = req.body as RequestInputSchema;            return res.json({bookName, authorName});        }    }

Implementing Validation in the Validations() Decorator

The @Validations() decorator supersedes the validations defined in the Method decorator. If the validations are of type InputValidation and the request method is one of [POST, PATCH, PUT], the validations apply to the request-body. Otherwise, they apply to the request-query-params.

{
    type RequestInputSchema = {        bookName: string,        authorName: string,    };
    // Validate the input. For POST, PATCH, and PUT, it's the body; otherwise, it's the query parameters.    @Validations({        bookName: {            required: true,            maxLength: 100,        },        authorName: {            required: true,            inList: ['My Auth 1', 'My Auth 2'] // Author can have only one of the 2 names        }    })    @Post('/another-endpoint')    private anotherHandler(req: Request, res: Response): Promise<Response>{
        const { bookName, authorName } = req.body as RequestInputSchema;
        return res.json({ bookName, authorName });    }
    @Validations(myHttpRequestValidations)    @Post('/awesome-endpoint/{id}')    private awesomeHandler(req: Request, res: Response): Promise<Response>{
        const { a, b } = req.body as RequestInputSchema;        const { id } = req.path as any;        const { cursor, sort } = req.query as any;
        return res.json({a, b, id, cursor, sort});    }}