Translating DTOs messages

[NiloufarPadkan]

I wanna translate validation errors using nestjs-18n . Here is an example of my login DTO which username and password are required.

import {
  IsString,
  IsNotEmpty,

} from 'class-validator'
import { i18nValidationMessage } from 'nestjs-i18n';

export class LoginDto {
  @IsNotEmpty({ message: 'validation.NOT_EMPTY' })
  username: string;
  @IsNotEmpty()
  @IsString()
  password: string;
}

when user does not enter username receives :

{
    "statusCode": 400,
    "message": "Bad Request",
    "errors": [
        {
            "property": "username",
            "target": {
                "password": "123456"
            },
            "children": [],
            "constraints": {
                "isNotEmpty": "نام کاربری نمیتواند خالی باشد"
            }
        }
    ]
}

but i wanna customize this error and get

{
    "message": [
        "username should not be empty"
    ],
    "error": "Bad Request",
    "statusCode": 400
}

[rubiin]

https://nestjs-i18n.com/guides/dto_validation/global-validation follow along

[NiloufarPadkan]

this link does not have any information about what i said but it has a link to what helped me finding answer
here :
If you want a different output, create your own interceptor! For an example look at the I18nValidationExceptionFilter.
i edited this file in my node modules and then patch it using patch-package in order to have my changes in different systems

[NorseJedi]

I'm thinking the links you want are actually these:
https://nestjs-i18n.com/guides/exception-filters
https://docs.nestjs.com/exception-filters

Instead of needing to patch files in node_modules (the very thought makes me slightly queasy ;)) you can just write your own filter to catch all exceptions and do whatever you want with them before returning them to the client.

I've done this to make sure exceptions return the same type of object to the client as it returns on a successful request (basically the last example in the second link above). Once I figure out how to stop nestjs-i18n from breaking my tests I'll implement translations in the same class.

It'll be something like this:

import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from '@nestjs/common';
import { HttpAdapterHost } from '@nestjs/core';
import { Response } from 'express';
import process from 'process';


@Catch() // Catches all exceptions
export class ApiExceptionFilter implements ExceptionFilter {
    constructor(private readonly httpAdapterHost: HttpAdapterHost) {
    }

    catch(ex: any, host: ArgumentsHost) {
        // In certain situations `httpAdapter` might not be available in the
        // constructor method, thus we should resolve it here.
        const { httpAdapter } = this.httpAdapterHost;

        const context = host.switchToHttp();
        const response = context.getResponse<Response>();

        // Anything that is't an http error should return a 500 (though in fairness, it probably already does...)
        const httpStatus = ex instanceof HttpException ? ex.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;

        let message = ex?.message || '';

        if (ex?.code) {
            message += `(Errorcode: ${ex.code})`;
        }

        message = do_magic_translation_stuff(message)


        const apiResponse = Object.assign(new ApiResponseDto<null>(), {
            success: false,
            error: Object.assign(new ApiErrorDto(), {
                code: httpStatus,
                message
            })
        });

        if (!(ex instanceof HttpException) && ex instanceof Error && (process.env.NODE_ENV == 'development' || process.env.NODE_ENV == 'test')) {
		    // Return the stacktrace for non-http exceptions unless we're in production
            apiResponse.error.stackTrace = ex.stack;
        }

        // Return the new response to the client
        httpAdapter.reply(response, apiResponse, httpStatus);
    }
}

And here are the Dto's used by the class:

export class ApiResponseDto {
    success: boolean = true;
    message?: string;
    data?: any|any[];
    error?: ApiErrorDto;
}

export class ApiErrorDto {
    code: number;
    message: string;
    additionalErrors?: ApiErrorDto[];
    stackTrace?: string;
}

Add it to the application in the app.module providers-array:

import { ApiExceptionFilter } from 'whereever/you/put/it';

@Module({
    providers: [
        { provide: APP_FILTER, useClass: ApiExceptionFilter }
    ]
})
export class AppModule {}

Hope it helps :)