Relaciones uno a uno embebidas

Curso de NestJS: Persistencia de Datos con MongoDB

Introducción

Persistencia de Datos con MongoDB y NestJS

Programación en Python para Principiantes

Persistencia de Datos en MongoDB con Node.js

Database

Configuración de Docker Compose para MongoDB

Conexión a MongoDB usando Mongo Compass en Docker

Conexión a MongoDB con NodeJS: Instalación y Configuración Básica

Inyección de Conexiones MongoDB en NestJS

Consultas Avanzadas con MongoDB y NestJS

Conexión a MongoDB con Variables de Entorno en Node.js

Mongoose

Instalación y Configuración de Mongoose con NestJS

Creación de Esquemas de Productos con Mongoose y NestJS

Operaciones CRUD con Mongoose y Node.js

CRUD de Productos con Mongo y Nest.js

Paginación de Datos en NestJS: Implementación Práctica

Paginación y Filtros en MongoDB con Node.js

Consultas Avanzadas con Rango de Precios en MongoDB

Indexación en MongoDB: Selección y Creación de Índices Eficientes

Relaciones en MongoDB

Relaciones Embebidas en MongoDB: Documentos Anidados y Validación

Relaciones Uno a Uno en MongoDB: Referencias y Subdocumentos

Relaciones Uno a Muchos en MongoDB: Arrays Embebidos y Referenciados

Tipado de Documentos Embebidos en NestJS con Mongoose

Relaciones uno a muchos en MongoDB: Arrays y Referencias

Manipulación de Arrays en Servicios Web con Node.js

Próximos pasos

Autentificación con MongoDB y Passport en NestJS

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

MongoDB es una base de datos No Relacional. Aun así, requerimos la posibilidad de crear relaciones entre documentos de diferentes colecciones y es posible hacerlo.

Documento dentro de otro documento

La relación más sencilla y más utilizada es guardando un documento dentro de otro, formando una relación uno a uno embebida.

{
  "name": "Producto Uno",
  "category": {
    "name": "Category",
    "image": "..."
  }
}

Implementación relación uno a uno

Implementar esta lógica con Mongoose y NestJS es muy sencillo.

Paso 1: preparar el esquema

Agrega la propiedad en tu esquema que contendrá el documento embebido.

// products/product.entity.ts
import { Prop, Schema, SchemaFactory, raw } from '@nestjs/mongoose';

export class Product extends Document {

  @Prop(
    raw({
      name: { type: String },
      image: { type: String },
    })
  )
  category: Record<string, any>;
}

El decorador @Prop() recibe un raw() con la estructura del objeto que estará dentro del objeto principal. La relación es resuelta gracias al tipado Record propio de TypeScript.

Paso 2: validar sub documento

El DTO será el encargado de validar la estructura de este sub documento.

// products/dto/category.dto.ts
import { IsString, IsNotEmpty, IsUrl } from 'class-validator';

export class CreateCategoryDto {

  @IsString()
  @IsNotEmpty()
  readonly name: string;
  
  @IsUrl()
  @IsNotEmpty()
  readonly image: string;
}

Prepara el DTO para la creación de la categoría con los campos que le corresponde a la misma que estarán embebidos dentro del documento principal.

// products/products.dto.ts
import { ValidateNested } from 'class-validator';
import { CreateCategoryDto } from './category.dtos';

export class CreateProductDto {

  @IsNotEmpty()
  @ValidateNested()
  @ApiProperty()
  readonly category: CreateCategoryDto;
}

Importa el DTO de la categoría y utilízalo como propiedad para el DTO de creación de productos. Agrégale el decorador @ValidateNested() para que NestJS haga la validación de la estructura correspondiente del objeto dentro.

De esta sencilla manera, puedes crear relaciones uno a una, o guardar un objeto dentro de otro en MongoDB a la vez que válidas la estructura del mismo.

Contribución creada por: Kevin Fiorentino (Platzi Contributor).

Código de ejemplo para relaciones uno a uno embebidas

// src/products/entities/product.entity.ts
import { Prop, Schema, SchemaFactory, raw } from '@nestjs/mongoose';

export class Product extends Document {
  ...

  @Prop(
    raw({
      name: { type: String },
      image: { type: String },
    }),
  )
  category: Record<string, any>; // 👈 new field
}

// src/products/dtos/category.dtos.ts
import { IsString, IsNotEmpty, IsUrl } from 'class-validator';

export class CreateCategoryDto {
  ...

  @IsUrl()
  @IsNotEmpty()
  readonly image: string; // 👈 new field
}

// src/products/dtos/products.dtos.ts

import {
  ValidateNested, // 👈 new decorator
} from 'class-validator';

import { CreateCategoryDto } from './category.dtos';  // 👈

export class CreateProductDto {

  @IsNotEmpty()
  @ValidateNested()
  @ApiProperty()
  readonly category: CreateCategoryDto; // 👈 new field
}