Cfrgtkky

Just wondering the best way to convert a NestJS entity object to a DTO.

Lets say I have the following:

import { IsString, IsNumber, IsBoolean } from 'class-validator';

import { Exclude } from 'class-transformer';



export class PhotoSnippetDto {

  @IsNumber()

  readonly id: number;



  @IsString()

  readonly name: string;



  constructor(props) {

    Object.assign(this, props);

  }

}



export class Photo {



  @IsNumber()

  id: number;



  @IsString()

  name: string;



  @IsString()

  description: string;



  @IsString()

  filename: string;



  @IsNumber()

  views: number;



  @IsBoolean()

  isPublished: boolean;



  @Exclude()

  @IsString()

  excludedPropery: string;



  constructor(props) {

    Object.assign(this, props);

  }

}



@Controller()

export class AppController {



  @Get()

  @UseInterceptors(ClassSerializerInterceptor)

  root(): PhotoSnippetDto {

    const photo = new Photo({

      id: 1,

      name: 'Photo 1',

      description: 'Photo 1 description',

      filename: 'photo.png',

      views: 10,

      isPublished: true,

      excludedPropery: 'Im excluded'

    });



    return new PhotoSnippetDto(photo);

  }



}

I was expecting the ClassSerializerInterceptor to serialize the photo object to the DTO and return something like this:

{

  id: 1,

  name: 'Photo 1'

}

But I'm getting a response containing all the properties still:

{

  id = 1,

  name = 'Photo 1',

  description = 'Photo 1 description',

  filename = 'file.png',

  views = 10,

  isPublished = true

}

I basically want to strip out all properties that are not defined in the DTO.

I know the ClassSerializerInterceptor works perfectly when using @Exclude(), I was just also expecting it to remove undefined properties also.

I'm curious as to the best way to go about this? I know I could do something like:

@Get('test')

@UseInterceptors(ClassSerializerInterceptor)

test(): PhotoSnippetDto {

  const photo = new Photo({

    id: 1,

    name: 'Photo 1',

    description: 'Photo 1 description',

    filename: 'photo.png',

    views: 10,

    isPublished: true,

    excludedPropery: 'Im excluded'

  });

  const { id, name } = photo;

  return new PhotoSnippetDto({id, name});

}

But if I ever want to add another property to the response I'd have to do more than just add the new property to the class.. I'm wondering if there's a better 'Nest way' of doing it.

One possible option is to mark your DTO object with the @Exclude and @Expose decorators and then do a conversion with plainToClass:

@Exclude()

export class PhotoSnippetDto {

   @Expose()

   @IsNumber()

   readonly id: number;



   @Expose()

   @IsString()

   readonly name: string;

}

Assuming you've decorated as above you can then do: const dto = plainToClass(PhotoSnippetDto, photo);

The resulting object is in the form you expect with only id and name showing up on the final object. If you decide later to expose more properties you can simply add them to your DTO and tag them with @Expose.

This approach also allows you to remove the constructor from your DTO that is using Object.assign

So based on Jesse's awesome answer I ended up creating the DTO using @Exclude() and @Expose() to remove all but exposed properties:

import { IsString, IsEmail } from 'class-validator';

import { Exclude, Expose } from 'class-transformer';



@Exclude()

export class PhotoSnippetDto {

   @Expose()

   @IsNumber()

   readonly id: number;



   @Expose()

   @IsString()

   readonly name: string;

}

And then I created a generic transform interceptor that calls plainToclass to convert the object:

import { Injectable, NestInterceptor, ExecutionContext } from '@nestjs/common';

import { Observable } from 'rxjs';

import { map } from 'rxjs/operators';

import { plainToClass } from 'class-transformer';



interface ClassType<T> {

    new(): T;

}



@Injectable()

export class TransformInterceptor<T> implements NestInterceptor<Partial<T>, T> {



    constructor(private readonly classType: ClassType<T>) {}



    intercept(context: ExecutionContext, call$: Observable<Partial<T>>, ): Observable<T> {

        return call$.pipe(map(data => plainToClass(this.classType, data)));

    }

}

And then use this interceptor to transform the data to any type:

@Get('test')

@UseInterceptors(new TransformInterceptor(PhotoSnippetDto))

test(): PhotoSnippetDto {

  const photo = new Photo({

    id: 1,

    name: 'Photo 1',

    description: 'Photo 1 description',

    filename: 'photo.png',

    views: 10,

    isPublished: true,

    excludedPropery: 'Im excluded'

  });

  return photo;

}

Which gives me what I wanted:

{

  id: 1,

  name: 'Photo 1'

}

Definitely feels more nest-like! I can use the same interceptor where ever I need and to change the response I only ever need to change the DTOs.

Happy days.