Introducci贸n

1

驴Ya terminaste el Curso de NestJS: Programaci贸n Modular?

2

Platzi Store: presentaci贸n del proyecto e instalaci贸n

Database

3

C贸mo instalar Docker para este proyecto

4

Configuraci贸n de PostgresSQL en Docker

5

Explorando postgres con interfaces gr谩ficas y terminal

6

Integraci贸n de node-postgres con NestJS

7

Conexi贸n como inyectable y ejecutando un SELECT

8

Usando variables de ambiente

TypeORM

9

驴Qu茅 es un ORM? Instalando y configurando TypeORM Module

10

Creando tu primera entidad

11

TypeORM: active record vs. repositories

12

Crear, actualizar y eliminar

13

Cambiar a Mysql demo (opcional)

Migraciones

14

Sync Mode vs. Migraciones en TypeORM

15

Configurando migraciones y npm scripts

16

Corriendo migraciones

17

Modificando una entidad

Relaciones

18

Relaciones uno a uno

19

Resolviendo la relaci贸n uno a uno en el controlador

20

Relaciones uno a muchos

21

Resolviendo la relaci贸n uno a muchos en el controlador

22

Relaciones muchos a muchos

23

Resolviendo la relaci贸n muchos a muchos en el controlador

24

Manipulaci贸n de arreglos en relaciones muchos a muchos

25

Relaciones muchos a muchos personalizadas

26

Resolviendo la relaci贸n muchos a muchos personalizada en el controlador

Consultas

27

Paginaci贸n

28

Filtrando precios con operadores

29

Agregando indexadores

30

Modificando el naming

31

Serializar

Migraci贸n a NestJS 9 y TypeORM 0.3

32

Actualizando Dependencias para NestJS 9

33

Cambios en TypeORM 0.3

34

Migraciones en TypeORM 0.3

Pr贸ximos pasos

35

C贸mo solucionar una referencia circular entre m贸dulos

36

Contin煤a con el Curso de NestJS: Autenticaci贸n con Passport y JWT

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Resolviendo la relaci贸n uno a uno en el controlador

19/36
Recursos

Aportes 5

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Cambiando el dto user

// src/users/dtos/user.dto
export class CreateUserDto {
  ...

	// Agregamos atributo
  @IsOptional()
  @IsNotEmpty()
  @ApiProperty() 
  readonly customerId: number; 
}

export class UpdateUserDto extends PartialType(CreateUserDto) {}

Modificando la funcion crear

Si el objeto contiene un customerId traemos los datos usando el servicio de customer

//src/users/services/user.service

async create(data: CreateUserDto) {
    const newUser = this.userRepo.create(data);
    if(data.customerId){
      const customer = await this.customerService.findOne(data.customerId);
      newUser.customer = customer;
    }
    return await this.userRepo.save(newUser);
  }

Modificando la funcion find

Si queremos que cuando se consulte al usuario tambien se obtengan los datos del customer debemos agregar la siguiente opcion

async findAll() {
    return await this.userRepo.find({
      relations: ['customer'] // esta
    });
  }

async findOne(id: number) {
  const user = await this.userRepo.findOne(id, {
    relations: ['customer'] // esta
  });
    
	if (!user) {
	    throw new NotFoundException(`User #${id} not found`);
	 }
   return user;
}

Resolviendo la relaci贸n uno a uno en el controlador

Vamos a resolver que al momento de crear un usuario, podamos mandar un id de un customer y as铆 mismo crear la relaci贸n, pero para esto primero debemos modificar el DTO de creaci贸n de usuario:

  • src/users/dtos/user.dto:
// ...

export class CreateUserDto {
  // ..

	// simplemente especificamos que existe esta propiedad
	// anadimos validaciones
  @IsPositive()
  @IsOptional()
  @ApiProperty()
  readonly customerId: number;
}

export class UpdateUserDto extends PartialType(CreateUserDto) {}

Ahora si, vamos a modificar nuestro servicio de usuarios y vamos a preguntar si existe un customerId, y si s铆, resolvamos la relaci贸n:

  • **src/users/services/user.service**:
// ...

import { User } from '../entities/user.entity';
import { CreateUserDto, UpdateUserDto } from '../dtos/user.dto';

import { ProductsService } from './../../products/services/products.service';
// importamos el servicio de Customers
import { CustomersService } from './customers.service';

@Injectable()
export class UsersService {
  constructor(
    // inyectamos el servicio de customers en nuestro servicio
    private customersService: CustomersService,
    @InjectRepository(User) private userRepo: Repository<User>,
  ) {}

  findAll() {
		// al momento de traer los usuarios, traemos su customer en caso de tenerlo
    return this.userRepo.find({
      where: { id },
      relations: ['customer'],
    });
  }

  async findOne(id: number) {
    // al momento de traer un usuario, traemos su customer en caso de tenerlo
    const user = await this.userRepo.findOne({
      where: { id },
      relations: ['customer'],
    });
    if (!user) {
      throw new NotFoundException(`Users #${id} not found`);
    }
    return user;
  }

  async create(data: CreateUserDto) {
    const newUser = this.userRepo.create(data);
    // si existe un customer el la data que nos env铆an
    if (data.customerId) {
      // encuentra a ese customer en base a su id
      const customer = await this.customersService.findOne(data.customerId);
      // relaciona al usuario con el customer
      newUser.customer = customer;
    }
    return this.userRepo.save(newUser);
  }

  // ...
}

Y listo, ya hemos resuelto la relaci贸n entre user y customer.

FindOne

Resolver relacion en el metodo findOne

    const product = await this.userRepository.findOne({
      where: { id },
      relations: ['customer'],
    });

Para obtener un usuario con su customer, en el m茅todo findOne, pueden hacer el siguiente cambio:

 async findOne(id: number) {
    const user = await this.userRepo.findOne(id, { relations: ['customer'] });
    if (!user) {
      throw new NotFoundException(`User #${id} not found`);
    }
    return user;
  }

El nombre de esta clase debe ser 鈥淩esolviendo la relaci贸n uno a uno en el SERVICIO鈥 pues al final es ah铆 donde mandamos la instrucci贸n de las relaciones.