Relaciones Uno a Muchos en MongoDB: Arrays Embebidos vs Referenciados
Clase 20 de 24 • Curso de NestJS: Persistencia de Datos con MongoDB
Contenido del curso
- 4

Configuración y ejecución de MongoDB con Docker Compose
08:51 - 5

Conexión a Base de Datos MongoDB con Mongo Compass
05:05 - 6

Instalación y conexión de MongoDB en Node con driver oficial
06:59 - 7

Inyección de Conexiones MongoDB en Servicios NestJS
06:57 - 8

Consultas a MongoDB con Nest.js: Implementación de Endpoints
04:46 - 9

Variables de Entorno para Configuración de MongoDB en Node.js
10:43
- 10

Instalación y Configuración de Mongoose con NestJS
07:52 - 11

Definición de Esquemas en Mongoose para eCommerce con NestJS
07:45 - 12

Operaciones CRUD con MongoDB y Node.js en un Servicio de Productos
09:29 - 13

Creación, actualización y eliminación de productos en MongoDB
10:12 - 14

Validación de MongoID con Pipes en NestJS
06:38 - 15

Paginación en MongoDB con DTOs y Validaciones en NestJS
11:13 - 16

Consultas Avanzadas con Rangos de Precios en MongoDB
07:30 - 17

Indexación en MongoDB: Cómo optimizar consultas rápidas
03:11
- 18

Relaciones embebidas en MongoDB: Manejo y ejemplos prácticos
07:55 - 19

Relaciones uno a uno referenciadas en MongoDB
12:20 - 20

Relaciones Uno a Muchos en MongoDB: Arrays Embebidos vs Referenciados
09:28 - 21
Tipado de Documentos Embebidos en NestJS con Mongoose
01:49 - 22

Relaciones Uno a Muchos Referenciadas en MongoDB
14:36 - 23

Manipulación de Arrays en E-commerce: Métodos y Endpoints
13:08
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
}