Relaciones uno a muchos embebidas

Curso de NestJS: Persistencia de Datos con MongoDB

Introducción

¿Ya tomaste el Curso de NestJS: Programación Modular?

Instalación de Docker para este curso

Instalación de Platzi Store y presentación

Database

Configuración de Docker para MongoDB

Exploración de la base de datos con Mongo Compass

Instalando y conectando MongoDB Driver

Conexión como inyectable

Ejecutando un query

Usando variables de ambiente en Mongo

Mongoose

¿Qué es Mongoose? Instalación y configuración

Implementando Mongoose en Módulos

Conectando Mongo a los servicios

Create, update y delete

Pipe para mongoid

Agregando paginación

Agregando un filtro de rango para precios

Agregando indexadores

Relaciones en MongoDB

Relaciones uno a uno embebidas

Relaciones uno a uno referenciadas

Relaciones uno a muchos embebidas

Cómo tipar relaciones uno a muchos embebidas

Relaciones uno a muchos referenciadas

Manipulación de arrays en MongoDB

Próximos pasos

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

Si ya tienes una cuenta,

Recursos

Un tipo de relación entre documentos en MongoDB es el “uno a muchos” de forma embebida. Así como puedes guardar un objeto dentro de otro, puedes guardar un array de objetos dentro de un objeto principal.

Array de documentos dentro de un objeto

Para lograr este tipo de relación, hazlo de la siguiente manera:

Paso 1: preparación del esquema

Agrega este nuevo tipo de relación en el esquema de tu colección de Mongo.

// users/customer.entity.ts
import { Document, Types } from 'mongoose';

export class Customer extends Document {

  @Prop({
    type: [{
      name: { type: String },
      color: { type: String }
    }],
  })
  skills: Types.Array<Record<string, any>>;
}

El decorador @Prop() recibe una propiedad type que es un array con un ejemplo de la estructura de datos que tendrá cada sub documento.

Paso 2: preparación del DTO

Ahora solo prepara el DTO para recibir este nuevo campo:

// users/customer.dto.ts
import { IsNotEmpty, IsArray } from 'class-validator';

export class Skills {  // Sub clase para tipar los datos

  @IsNotEmpty()
  name: string;
  
  @IsNotEmpty()
  color: string;
}

export class CreateCustomerDto {

  @ValidateNested()
  @Type(() => Skills)
  readonly skills: Skills[];
}

Creamos una clase auxiliar denominada Skills que utilizaremos para tipar los datos y el decorador @ValidateNested() que hará la validación de forma recursiva, objeto por objeto dentro del array.

De esta manera, ya puedes guardar todo un array de objetos, dentro de un documento principal. Ten en cuenta que cada documento de MongoDB tiene un máximo de tamaño de 16MB. Considera esto a la hora de diseñar tu base de datos.

Contribución creada por Kevin Fiorentino (Platzi Contributor), con aportes de Guillermo Rodas Gómez.

Código de ejemplo para relaciones uno a muchos embebidas

// src/users/entities/customer.entity.ts
import { Document, Types } from 'mongoose';

export class Customer extends Document {
  ...
  @Prop({
    type: [{ name: { type: String }, color: { type: String } }],
  })
  skills: Types.Array<Record<string, any>>; // 👈 field
}

// src/users/dtos/customer.dto.ts
import {
  IsString,
  IsNotEmpty,
  IsPhoneNumber,
  IsArray, // 👈 new decorator
  ValidateNested,  // 👈 new decorator
} from 'class-validator';
import { PartialType } from '@nestjs/swagger';

export class CreateCustomerDto {
   ...
  @IsArray()
  @IsNotEmpty()
  readonly skills: any; // 👈 new field
}

Aportes 2

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Guillermo Rodas Gómez

hace 4 años

Buenas, he conseguido que se pueda tipar y validar los skills del customer con estos cambios

Cree una clase Skills que contengan los atributos a validar

export class Skills {
  @IsNotEmpty()
  name: string;

  @IsNotEmpty()
  color: string;
}

Luego hice que la variable skills sea del tipo array de Skills y le coloqué el decorador @ValidateNested(), y el decorar @Type especificando el tipo de array:

 @ValidateNested()
  @Type(() => Skills)
  readonly skills: Skills[];

Obteniendo así el archivo customer.dto.ts

import {
  IsString,
  IsNotEmpty,
  IsPhoneNumber,
  ValidateNested,
} from 'class-validator';
import { PartialType } from '@nestjs/swagger';
import { Type } from 'class-transformer';

export class Skills {
  @IsNotEmpty()
  name: string;

  @IsNotEmpty()
  color: string;
}

export class CreateCustomerDto {
  @IsString()
  @IsNotEmpty()
  readonly name: string;

  @IsString()
  @IsNotEmpty()
  readonly lastName: string;

  @IsPhoneNumber()
  @IsNotEmpty()
  readonly phone: string;

  @ValidateNested()
  @Type(() => Skills)
  readonly skills: Skills[];
}

export class UpdateCustomerDto extends PartialType(CreateCustomerDto) {}

He aquí una prueba de las validaciones

Kevin Fiorentino

hace 2 años

Los documentos en MongoDB pueden tener un peso máximo de 16MB cada uno. Considerar esto cuando vayan a diseñar un nuevo esquema.