proyecto nuevo config module

creo un nuevo proyecto.

 Lo primero que haremos es acomodar la configuración, para el lo crearemos un modulo congfig desde el cual gestionaremos las variables de entorno.

nest generate module config

esto creará 

PS C:\Users\Usuario\Desktop\pro\proyecto> nest generate module config

CREATE src/config/config.module.ts (83 bytes)

UPDATE src/app.module.ts (316 bytes)

se crea un nuevo modulo llamado config y se agrega al modulo peincipal app.module.  Desde ahora todos los cambios que hagamos en config.module se veran reflejados a nievel global.

ahora crearemos en la base del proyectro un archivo .env que contendrá las variables de entorno que usaremos. El archivo ,env lucirá así

#puerto a usar

PORT=8081

#ambiente de trabajo

NODE_ENV=development

#bases de datos

DB_HOST=localhost

DB_PORT=3306

DB_USER=root

DB_PASSWORD=1234

DB_NAME=ejemplo

esto permitiria usar el puerto 808 en vez del 3000 que viene por defecto, además contiene los valores de la base de datos que ya hemos creado en nuestro mysql llemadas ejemplo.

ahora descargaremos en el proyecto el typeorm, y mysql2 

npm install --save @nestjs/typeorm typeorm mysql2

el resultado será

PS C:\Users\Usuario\Desktop\pro\proyecto> npm install --save @nestjs/typeorm typeorm mysql2

added 39 packages in 11m

PS C:\Users\Usuario\Desktop\pro\proyecto> 

 

CONTINUAR LEYENDO

creacion de servicios y controladores dentro de los modulos

 Los controladores son los que han de recibir los llamados enrutado por la api y ustos usarán los servicios que les sena injectados y son estos servicios los que tendrán la lógica de negocio , los que unirán con la base de datos  y permitirán que se haga el crud.

hasta ahora hemos construido dos modelos ahora dentro de cada modelos formaremos sus controladores y servicios usando en la terminal con el comando:

 nest g co user/user

nest g s user/user

 nest g co task/task

 nest g co task/task

lo cual generaá los siguiente: 

PS C:\Users\Usuario\Desktop\pro> nest generate module user

CREATE src/user/user.module.ts (81 bytes)

PS C:\Users\Usuario\Desktop\pro> nest generate module task

CREATE src/task/task.module.ts (81 bytes)

UPDATE src/app.module.ts (520 bytes)

CREATE src/user/user/user.controller.ts (97 bytes)

CREATE src/user/user/user.controller.spec.ts (478 bytes)

UPDATE src/user/user.module.ts (171 bytes)

CREATE src/user/user/user.service.ts (88 bytes)

UPDATE src/user/user.module.ts (250 bytes)

PS C:\Users\Usuario\Desktop\pro>  nest g co task/task

CREATE src/task/task/task.controller.ts (97 bytes)

CREATE src/task/task/task.controller.spec.ts (478 bytes)

UPDATE src/task/task.module.ts (171 bytes)

PS C:\Users\Usuario\Desktop\pro> nest g s task/task

CREATE src/task/task/task.service.ts (88 bytes)

CREATE src/task/task/task.service.spec.ts (446 bytes)

UPDATE src/task/task.module.ts (250 bytes)

PS C:\Users\Usuario\Desktop\pro> 

ya se vcrearon los controladores y servicios para cada modelo y estos fueron automáticamente incluido dentro de sus respectivos modelos.

el servicio creado tendrá la siguiente forma

import { Injectable } from '@nestjs/common';

@Injectable()

export class TaskService {}

y los controladores

import { Controller } from '@nestjs/common';

@Controller('task')

export class TaskController {}

y el modulo quedaria así

import { Module } from '@nestjs/common';

import { TaskController } from './task/task.controller';

import { TaskService } from './task/task.service';

@Module({

  controllers: [TaskController],

  providers: [TaskService],

})

export class TaskModule {}

CONTINUAR LEYENDO

nest creacion de modulos

 es buena práctica crear un modulo aparte por cada entidad. y cargarlo en el modulo principal esto ayuda al mantenimiento y escalabilidad de la aplicación.

en el presente ejemplo crearemos dos modulos cuyas tablas estarán relacionadas con una relación uno a muchos, donde un user podrá escribir multiples tareas.  

lo primero que haremos es crear los Modulos con 

nest generate module user

nest generate module task

Los resultadros serán: en consolo los siguientes:

PS C:\Users\Usuario\Desktop\pro> nest generate module user

CREATE src/user/user.module.ts (81 bytes)

UPDATE src/app.module.ts (459 bytes)

PS C:\Users\Usuario\Desktop\pro> nest generate module task

CREATE src/task/task.module.ts (81 bytes)

UPDATE src/app.module.ts (520 bytes)

PS C:\Users\Usuario\Desktop\pro> 

Como notarás en ambos caso se genera una nueva a carpeta dentro de src, dentro de la cual se genra el modulo user y task. además se modifica el modulp principal app.module agregando los modulos creados.

Si abrimos los modulos creados tendrán los siguientes aspectos:

import { Module } from '@nestjs/common';

@Module({})

export class UserModule {}

y 

import { Module } from '@nestjs/common';

@Module({})

export class TaskModule {}

observa que los modulos son son más que un @module y una clase exportable

el app.module ahora lucirá así

import { Module } from '@nestjs/common';

import { AppController } from './app.controller';

import { AppService } from './app.service';

//importo el moduloconfigMOdule

import { AppConfigModule } from './config.module';

import { UserModule } from './user/user.module';

import { TaskModule } from './task/task.module';

@Module({

  imports: [AppConfigModule, UserModule, TaskModule],

  controllers: [AppController],

  providers: [AppService],

})

export class AppModule {}

observa que los modelos ya han sido incorporados dentro de este modulo dentro de imports:[],

desde ahora todo lo que se genere dentro de los modelos app.modulo lo porá usar.

CONTINUAR LEYENDO

nest dotenv

 

esta librerai sirve para facilitar el proceso de cargar variables de entorno así si desea lo primero que debe de hacer es tener en la raiz del proyecto una carpeta .env con las variables de entorno por ejemplo

PORT=3000

NODE_ENV=development

DB_HOST=localhost

DB_PORT=3306

DB_USER=root

DB_PASSWORD=1234

DB_NAME=ejemplo

ahora descargue dotenv usando en la terminal el comando 

npm install --save dotenv

ahora agregue a la carpeta main.ts la configuración de dotenv

import { NestFactory } from '@nestjs/core';

import { AppModule } from './app.module';

import * as dotenv from 'dotenv';

async function bootstrap() {

  dotenv.config(); // Carga las variables de entorno

  const app = await NestFactory.create(AppModule);

  await app.listen(process.env.PORT);

}

bootstrap();

ya tiene de forma global las variables de estado, escritas en .env. ahora para usar esas variables de estado solo las deberás llamar usando process.env._variable escogida  por ejemplo :

process.env.PORT

para asegurarte de que todo quedó bien instalado puede hacer un console.log en el swerrvicio principal, y cada vez que este servciio sea llamado debe imprinir en consola por ejemplo en appservice:

import { Injectable } from '@nestjs/common';

@Injectable()

export class AppService {

  getHello(): string {

    return 'es gersom el que escribe';

  }

}

pues coorer la aplicacion con nest start en la consola y luego llamar desde el buscador a localhost:3000

 y deberá imprimir en la terminal

3000

development

3306

CONTINUAR LEYENDO

nest configuracion

$ npm i --save @nestjs/config

creo el arcivo .env para cargar las variables de entornos en la base del proyecto

se crea la primera variable de entorno PORT:3000

#confiuracion de la aplicacion

PORT =3000

ahora vamos al appModule para configurar

import { Module } from '@nestjs/common';

// importo el type Ormmodule para hacer las base de datos

import { TypeOrmModule } from '@nestjs/typeorm';

// mis modulos

import { TwitsModule } from './modules/twits/twits.module';

import { UsersModule } from './modules/users/users.module';

import { ConfigModule } from '@nestjs/config';

@Module({

  imports: [

    // importo el modulo para poder usarlo

    ConfigModule.forRoot({

      //paso un argumento

      isGlobal: true, // sirve para hacer de uso global las variabkles

    }),

ahora en appmodule hago un cosntructor

export class AppModule {

  constructor(){}

}

Ahora en el constructor injecto el confit serve para usarlo

export class AppModule {

  constructor(private readonly configService: ConfigService) {}

}

es importamte tener mportado 

import { ConfigModule, ConfigService } from '@nestjs/config';

hagamos una propiedad estática port de tipo number

export class AppModule {

  static port:number;

  constructor(private readonly configService: ConfigService) {

   

  }

}

 ahola le asigno a esta propiedad estática un valor 

export class AppModule {

  static port: number;

  constructor(private readonly configService: ConfigService) {

    //PORT viene del archivo .env creado

    AppModule.port = this.configService.get('PORT');

  }

}

ahora agrego un signo de + delante de this. para garantizar que el valor sea castiado a number

export class AppModule {

  static port: number;

  constructor(private readonly configService: ConfigService) {

    //PORT viene del archivo .env creado

    AppModule.port = +this.configService.get('PORT');

  }

}

ahora vamos al main.ts ys sutituir 3000 por port

 antes 

  await app.listen(3000);

ahora debe quedar asi

  await app.listen(AppModule.port);

CONTINUAR LEYENDO

nest insercion en cascada

 voy al dto de createtwit

que se ve asi por ahora

import { IsString } from 'class-validator';

export class CreateTwitDto {

  @IsString() // la propiedad debe existeir y ser de tipo strint

  readonly menssage: string;

 

}

lo arreglo asi

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

import { User } from 'src/modules/users/entities';

export class CreateTwitDto {

  @IsString() // la propiedad debe existeir y ser de tipo strint

  readonly menssage: string;

  // insercion en cascada

  @IsObject()

  readonly user: Partial<User>;

}

ahora en el servicio de twit deberé injectar el repository de usuario

quedando asi

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

import { Twits } from './twits.entity';

import { CreateTwitDto } from './dto/create-twit.dto/create-twit.dto';

import { UddateTwitDto } from './dto/uddate-twit.dto/uddate-twit.dto';

import { Repository } from 'typeorm';

import { InjectRepository } from '@nestjs/typeorm';

import { PaginationQueryDto } from './dto';

import { User } from '../users/entities';

@Injectable()

export class TwitsService {

  constructor(

    @InjectRepository(Twits)

    private readonly twitsRepository: Repository<Twits>,

    @InjectRepository(User)

    private readonly usersRepository: Repository<User>,

  ) {}

ahora modificaremos el metodo create

añado user como parametro tambien

async createTwit({ menssage, user }: CreateTwitDto): Promise<Twits> {

    const twit: Twits = this.twitsRepository.create({ menssage, user });

    return this.twitsRepository.save(twit);

  }

ahora voy al modelo twit einserto la propiedad  user

import { Module } from '@nestjs/common';

import { TwitsController } from './twits.controller';

import { TwitsService } from './twits.service';

import { TypeOrmModule } from '@nestjs/typeorm';

import { Twits } from './twits.entity';

import { User } from '../users/entities';

@Module({

  imports: [TypeOrmModule.forFeature([Twits, User])],

  controllers: [TwitsController],

  providers: [TwitsService],

})

export class TwitsModule {}

CONTINUAR LEYENDO

nest paginacion

 en la carpeta dto dentro de twits

debo crear una nueva pagina llamada paginacion-query.dto.ts

/* eslint-disable prettier/prettier */

import { IsNumber, IsOptional, IsPositive } from 'class-validator';

export class PaginationQueryDto {

  @IsNumber()

  @IsPositive()

  @IsOptional()

  limit?: number;

  @IsNumber()

  @IsPositive()

  @IsOptional()

  offset?: number;

}

voy a servicio twit

  async getTwits(pagination: PaginationQueryDto): Promise<Twits[]> {

    const { limit, offset } = pagination;

    return await this.twitsRepository.find({

      relations: ['user'],

      skip: offset,

      take: limit,

    });

  }

incorporo como parametro la painationquerydto y lo desestructuro en limit y offset.

 luego agrego esto ami busqueda en find() donde ship; representa los campos a saltar y take la cantidad a buscar

ahora debo cambiar el contrlador

   @Get()

  async getTwitsFilter(

    @Query() pagination: PaginationQueryDto,

  ): Promise<Twits[]> {

    return await this.twitService.getTwits(pagination);

  }

ahora como nuestro dto require los parametros en numero y llegarn en string debo castiarlo a si que en main debo agregar una funcionalidad que lo castee de string a number, para ello usaremos    transformOptions: {

              enableImplicitConversion: true, 

  app.useGlobalPipes(

    new ValidationPipe({

      //lo que se envia sera de un objeto de la dto

      transform: true,

      // whitelist filtra la data maliciosa dejando sólo la que corresponda al dto

      whitelist: true,

      // cualquier propiedad adicionalo a la que necesita nuestro medto crea un

      //error 404

      forbidNonWhitelisted: true,

      //castean de string a number

      transformOptions: {

        //con esto nos aseguramos que los tipos de type

        //que entran siempre rseran correctos

        enableImplicitConversion: true,

      },

    }),

  );

CONTINUAR LEYENDO

nest campos relacionados

 Obteniendo campos realcionados

en el servcio twits hay que incorporar en find() y findOne() 

relación

  async getTwits(): Promise<Twits[]> {

    //ahora retornará el await

    // find hará un select all de sql, es decir traiem todo

    return await this.twitsRepository.find({ relations: ['user'] });

  }

  async getTwit(id: number): Promise<Twits> {

    const twit: Twits = await this.twitsRepository.findOne({

      where: { id },

      relations: ['user'],

    });

    if (!twit) {

      throw new NotFoundException('Resource Not Found');

    }

    return twit;

  }

CONTINUAR LEYENDO

nest usuario

 nest g mo modules/Users

creará

CREATE src/modules/users/users.module.ts (82 bytes)

UPDATE src/app.module.ts (688 bytes)

en ese modulo se crea una carpeta llamada entities

a dentro se crea un archivo index.ts

además se crea uotro documento llamado user.entity.ts

/* eslint-disable prettier/prettier */

import { Twits } from 'src/modules/twits/twits.entity';

import { Column, CreateDateColumn, Entity, OneToMany, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';

@Entity()

export class User {

    @PrimaryGeneratedColumn('increment')

  id: number;

  @Column({nullable:false})

  name: string;

  @Column({nullable:false})

  email: string;

  @Column({nullable:false})

  userName:string;

  @Column({nullable:false})

  password:string;

  //trelaciona con la clase twituser con una relacion uno a muchos

  @OneToMany(type=>Twits,Twits=>Twit.user)

  twits:Twits[];

  @CreateDateColumn()

  createAt:Date;

  @UpdateDateColumn()

  updateAt:Date;

 

 

}

ahora exportod desde index.ts

/* eslint-disable prettier/prettier */

export { User } from './user.entity';

}

ahora importo desde el modulo user al tyormmoduel

import { Module } from '@nestjs/common';

import { TypeOrmModule } from '@nestjs/typeorm';

import { User } from './entities/user.entity';

@Module({

  imports: [TypeOrmModule.forFeature([User])],

})

export class UsersModule {}

ahora debo garantizar qeu twit entity tega el campo user

import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';

import { User } from '../users/entities/user.entity';

@Entity( )

export class Twits {

  //este decorador sirver para crear las columnas en la base de datois

  //crea un id automático en la base de datos

  @PrimaryGeneratedColumn('increment')

  id: number;

  @Column()

  menssage: string;

 @ManyToOne(type => User, User=>User.twits,{cascade:true})

 @JoinColumn({name:'user-id'})

  user:User;

}

CONTINUAR LEYENDO

nest repositorios

 coloco un cosnstructir en el servicio de tuiot

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

import { Twits } from './twits.entity';

import { CreateTwitDto } from './dto/create-twit.dto/create-twit.dto';

import { UddateTwitDto } from './dto/uddate-twit.dto/uddate-twit.dto';

import { Repository } from 'typeorm';

@Injectable()

export class TwitsService {

  constructor(private readonly TwitsRepository: Repository<Twits>) {}

  // creo un ejmlo para trabajar

para retornar la información que se encuentra en la base de Datos 

  // El get lo voy a hacer aincronico y traerá una promesa

  async getTwits(): Promise<Twits[]> {

    //ahora retornará el await

    // find hará un select all de sql, es decir traiem todo

    return await this.twitsRepository.find();

creo una funcion asincrona, que regrezará un tipo promesa, Promise esta es una función genérica así que cloco >Twits[] > que es la entidad del modulp que estoy trabajando, esta función como ya estamos conectado a la base de dato traer´pa todos los valores de la tabla de datos. aqui el metodo find es el equivalente  a select all de  mysql.

para obtener un solo dato se usa el findOne

 async getTwit(id: number): Promise<Twits> {

    const twit = await this.twitsRepository.findOne({ where: { id } });

    if (!twit) {

      throw new NotFoundException('Resource Not Found');

    }

    return twit;

  }

Se crea una funcnión asincrónica que recibe el id desde el fronend , esta función devolverá una promeza y el modelo será Twit.  entonces espero un awit  que usa el repositorio creado y con el método findone  extrae solo el dato que necesita, el del id.

si el id no existe genera una excepcion notfound exception 404, pero si existe retorna el dato pedido

para ageregar un nuevo twits se usa 

 async createTwit({ menssage }: CreateTwitDto): Promise<Twits>{

    const twit = this.twitsRepository.create({ menssage });

    return this.twitsRepository.save(twit);

  }

donde create genera el nuevo mensaje, yse guarada en la contstante twit ahor5a esta se salva y retorna

para actulizar

 async updateTwit(id: number, { menssage }: UddateTwitDto): Promise<Twits> {

    const twit: Twits = await this.twitsRepository.preload({

      id,

      menssage,

    });

    if (!twit) {

      throw new NotFoundException('Resource Not Found');

    }

    twit.menssage = menssage;

    return twit;

  } }

 

proload busca y actuliza si existe

CONTINUAR LEYENDO

nest creamndo primera entidad

 se crea la crapeta twit.entity.ts con la siguiente informacion

/* eslint-disable prettier/prettier */

import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity( )

export class Twits {

  //este decorador sirver para crear las columnas en la base de datois

  //crea un id automático en la base de datos

  @PrimaryGeneratedColumn('increment')

  id: number;

  @Column()

  menssage: string;

arreglo id en a number

importo tyorg al modulo

import { Module } from '@nestjs/common';

import { TwitsController } from './twits.controller';

import { TwitsService } from './twits.service';

import { TypeOrmModule } from '@nestjs/typeorm';

import { Twits } from './twits.entity';

@Module({

  imports: [TypeOrmModule.forFeature([Twits])],

  controllers: [TwitsController],

  providers: [TwitsService],

})

export class TwitsModule {}

si guardo ya se debe haceber creado la tabla

CONTINUAR LEYENDO

nest base data mysql

 se descargan estos tres paquetes

npm install --save @nestjs/typeorm typeorm mysql2

en el app.module oimporto el tyorm module

import { Module } from '@nestjs/common';

// importo el type Ormmodule para hacer las base de datos

import { TypeOrmModule } from '@nestjs/typeorm';

// mis modulos

import { TwitsModule } from './modules/twits/twits.module';

@Module({

  imports: [TwitsModule, TypeOrmModule],

})

export class AppModule {}

configuro el forRoot

import { Module } from '@nestjs/common';

// importo el type Ormmodule para hacer las base de datos

import { TypeOrmModule } from '@nestjs/typeorm';

// mis modulos

import { TwitsModule } from './modules/twits/twits.module';

@Module({

  imports: [

    TwitsModule,

    TypeOrmModule.forRoot({

      type: 'mysql',

      host: 'localhost',

      port: 3306,

      username: 'root',

      password: '1234',

      database: 'my_database',

      //autoloadentetis hace que los modelos se carguen solo sin especificarlo

      autoLoadEntities: true,

      synchronize: true,

    }),

  ],

})

export class AppModule {}

ahora para saber si funciono debo colocar :

nest start y debe salir lo siguiente

Nest] 12728  - 11/05/2023, 2:03:56 p. m.     LOG [InstanceLoader] TypeOrmModule dependencies initialized +2ms

[Nest] 12728  - 11/05/2023, 2:03:56 p. m.     LOG [InstanceLoader] TypeOrmCoreModule dependencies initialized +211ms

CONTINUAR LEYENDO

nest filtarr data maliciosa

 Debo agreagra en el validador en main .ts wl whitelist que sirve para dejatr pasar 

sólo la data que corresponde a la logica de dto  ante una mayor información que le llegue

import { NestFactory } from '@nestjs/core';

import { AppModule } from './app.module';

import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {

  const app = await NestFactory.create(AppModule);

  // para validar los dto al entrar

  app.useGlobalPipes(

    new ValidationPipe({

      //lo que se envia sera de un objeto de la dto

      transform: true,

      // whitelist filtra la data maliciosa dejando sólo la que corresponda al dto

      whitelist: true,

    }),

  );

  await app.listen(3000);

}

bootstrap();

la seguridad se puede aumentar más a travpes de forbiNOnWhiteListed, que si se recibe más información

 de la requerida crea un error 404 y lo devuelve pero no permite la operación

import { NestFactory } from '@nestjs/core';

import { AppModule } from './app.module';

import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {

  const app = await NestFactory.create(AppModule);

  // para validar los dto al entrar

  app.useGlobalPipes(

    new ValidationPipe({

      //lo que se envia sera de un objeto de la dto

      transform: true,

      // whitelist filtra la data maliciosa dejando sólo la que corresponda al dto

      whitelist: true,

      // cualquier propiedad adicionalo a la que necesita nuestro medto crea un

      //error 404

      forbidNonWhitelisted: true,

    }),

  );

  await app.listen(3000);

}

bootstrap();

CONTINUAR LEYENDO

nest transformación de data en DTO

 dto dreate transfer object

json de entrrada -> DTO-> SERVICIO

LUEGO OCURRE EL CAMINO CONTRARIO

PARA ELLO SE CREA UNA CLASE DENTRO DEL MODULO QUE SE NECESITE EN UNA CARPETA DTO ASI

 nest g cl modules/twits/dto/create-twit.dto

PS C:\Users\Usuario\Desktop\backend>  nest g cl modules/twits/dto/create-twit.dto --no-spec 

CREATE src/modules/twits/dto/create-twit.dto/create-twit.dto.ts (30 bytes)

PS C:\Users\Usuario\Desktop\backend> 

nest g cl modules/twits/dto/uddate-twit.dto --no-spec

CREATE src/modules/twits/dto/uddate-twit.dto/uddate-twit.dto.ts (30 bytes)

PS C:\Users\Usuario\Desktop\backend>  nest g cl modules/twits/dto/uddate-twit.dto --no-spec

CREATE src/modules/twits/dto/uddate-twit.dto/uddate-twit.dto.ts (30 bytes)

PS C:\Users\Usuario\Desktop\backend> 

ahora debo crear un nuevo documento en la carpeta dto que contenga cada uno de estos dto y la llameremos index.ts

import {CreateTwitDto } from './create-twit.dto/create-twit.dto'

import {UddateTwitDto} from './uddate-twit.dto/uddate-twit.dto'

ahora debo acomodar los dos cocumentos creado de dto

export class CreateTwitDto {

  readonly message: string;

}

export class UddateTwitDto {

  readonly message: string;

}

ahora debo descargar el clas validator y el class transformer

npm i class-validator class-transformer

 ahora se exporta en lo dto de class validator @ isString

import { IsString } from "class-validator";

export class UddateTwitDto {

  @IsString() // la propiedad debe existeir y ser de tipo strint

  readonly message: string;

}

hora se lleva el dto al controlador del modulo

  createTwit(@Body() menssage: CreateTwitDto): void {

    return this.twitService.createTwit(menssage);

  }

  @Patch(':id')

  // eslint-disable-next-line @typescript-eslint/no-unused-vars

  updateTwit(@Param('id') id: string, @Body() twit: UddateTwitDto): Twits {

    return this.twitService.updateTwit(id, twit);

  }

ahora debemos cambiar tambien el servicio pues ya no le enviamos un mendsaje sino un objeto

  createTwit({ menssage }: CreateTwitDto): void {

    this.twits.push({

      id: Math.floor(Math.random() * 2000 + 1).toString(),

      menssage: menssage,

    });

  }

  updateTwit(id: string, { menssage }: UddateTwitDto): Twits {

    const twit: Twits = this.getTwit(id);

    twit.menssage = menssage;

    return twit;

  }

ahora se debe agregar un pipe en el main.ts para qeu se castee la información que llega a la

import { NestFactory } from '@nestjs/core';

import { AppModule } from './app.module';

import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {

  const app = await NestFactory.create(AppModule);

  // para validar los dto al entrar

  app.useGlobalPipes(

    new ValidationPipe({

      //lo que se envia sera de un objeto de la dto

      transform: true,

    }),

  );

  await app.listen(3000);

}

bootstrap();

CONTINUAR LEYENDO