Cursos Empresas Blog Live Conf Eventos Precios

En las relaciones embebidas usamos las siguientes dos formas:

Para relaciones 1:1 embebidas:

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

Para relaciones 1:N embebidas:

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

Sin embargo en los dos usamos any lo cual hace que no tengamos un tipado en estos documentos embebidos, por eso vamos a ver otra forma de lograrlo.

La solución

Lo primero es que vamos a crear un esquema para ese documento embebido, de esta manera:

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

@Schema()
export class SubDoc {
  @Prop()
  name: String;

  @Prop()
  description: String;
}

export const SubDocSchema = SchemaFactory.createForClass(SubDoc);

Con su respectivo DTO:

// src/products/dtos/sub-doc.dto.ts
import { IsString, IsNotEmpty } from 'class-validator';
import { PartialType } from '@nestjs/swagger';

export class CreateSubDocDto {
  @IsString()
  @IsNotEmpty()
  readonly name: String;

  @IsString()
  @IsNotEmpty()
  readonly description: String;
}

export class UpdateSubDocDto extends PartialType(CreateSubDocDto) {}

Luego importamos este SubDoc dentro de la entidad que queramos que maneje la relación, así:

// src/products/entities/product.entity.ts

import { SubDoc, SubDocSchema } from './sub-doc.entity'; // 👈 import

...
export class Product extends Document {
  ...
  
  @Prop({ type: SubDocSchema })
  subDoc: SubDoc;  // 👈 new field (1:1)

  @Prop({ type: [SubDocSchema] })
  subDocs: Types.Array<SubDoc>;  // 👈 new field (1:N)
}
...

Debes tener en cuenta que este SubDoc no va a estar declarado en el módulo, ya que es un documento embebido y no una colección.

Con esto ya tienes el objeto embebido con tipado y además lo puedes incluir en tus DTOS para una validación más poderosa, de la siguiente manera:

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

import { ..., IsArray } from 'class-validator';
import { Type } from 'class-transformer'; // 👈 transform

import { CreateSubDocDto } from './sub-doc.dto'; // 👈 import

export class CreateProductDto {
  ...

  @IsNotEmpty()
  @ValidateNested()
  readonly subDoc: CreateSubDocDto;  // 👈 1:1

  @IsNotEmpty()
  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => CreateSubDocDto)
  readonly subDocs: CreateSubDocDto[];  // 👈 1:N
}

En este punto puedes crear un producto con un documento embebido de forma tipada y con una validación profunda, puedes ver esta forma en la rama 18 del proyecto por si quieres revisar el código a más detalle.

Si haces un POST te debería resultar algo así:

Tipado de Documentos Embebidos en NestJS con Mongoose

Curso de NestJS: Persistencia de Datos con MongoDB

Clase 21 de 24

Clase 21 / 24

Josué Eliezer Gómez Soto

Hace 5 años

A mi no me funciono el tipado, y revise mi código y no tengo todo correcto:

Mi entidad:

import { Prop, SchemaFactory } from '@nestjs/mongoose';

export class Address {
  @Prop({ type: String, required: true })
  department: string;

  @Prop({ type: String, required: true })
  city: string;

  @Prop({ type: String, required: true })
  suburb: string;

  @Prop({ type: String })
  street: string;

  @Prop({ type: String })
  passage: string;

  @Prop({ type: String })
  complement: string;
}

export const AddressSchema = SchemaFactory.createForClass(Address);

Mi DTO

import { IsNotEmpty, IsString } from 'class-validator';
import { PartialType } from '@nestjs/mapped-types';

export class AddressDTO {
  @IsString()
  @IsNotEmpty()
  readonly department: string;

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

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

  @IsString()
  readonly street: string;

  @IsString()
  readonly passage: string;

  @IsString()
  readonly complement: string;
}

export class UpdateAddressDTO extends PartialType(AddressDTO) {}

Esto va a la entidad:

import { PartialType } from '@nestjs/mapped-types';
import { Type } from 'class-transformer';
import { AddressDTO } from './address.dto';
import {
  IsArray,
  IsEmail,
  IsNotEmpty,
  IsNumber,
  IsString,
  ValidateNested,
} from 'class-validator';

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

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

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

  @IsNumber()
  @IsNotEmpty()
  readonly phone: number;

  @IsEmail()
  @IsNotEmpty()
  email: string;

  @IsNotEmpty()
  @IsArray()
  @ValidateNested({ each: true })
  @Type(() => AddressDTO)
  readonly address: AddressDTO[];
}

export class UpdateCustomerDTO extends PartialType(CreateCustomerDTO) {}

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document, Types } from 'mongoose';
import { Address, AddressSchema } from './address';

@Schema()
export class Customer extends Document {
  @Prop({ type: String, required: true })
  name: string;

  @Prop({ type: String, required: true })
  lastname: string;

  @Prop({ type: String, required: true })
  password: string;

  @Prop({ type: Number, required: true })
  phone: number;

  @Prop({ type: String, required: true })
  email: string;

  @Prop({ type: [AddressSchema] })
  address: Types.Array<Address>;
}

export const CustomerSchema = SchemaFactory.createForClass(Customer);

Comentarios (8)8 comentarios

Nicolas Molina

Profesor

Hace 6 años

👈 En esta lectura está la solución de como lograr las relaciones embebidas incluyendo el tipado.

Hace 3 años

Pregunta, porque este Schema, la clase no extiende de Document?

Otra pregunta, porque la propiedad usa String, en lugar de solo string:

name: String; vs name string;

Ivonne lizeth Tarapués Rodríguez

Para que Swagger se muestre correctamente se debe agregar:

  @ApiProperty({ type: () => [CreateSubDocDto]}) 
  readonly subDocs: CreateSubDocDto[];

De igual manera me parece que los tipos de las propiedades deben ser string en lugar de String, sino Swagger los muestra como objetos.

readonly description: string;

Catalano Nicolas

Hace 4 años

Excelente aporte! Muchas gracias!

Fernando Cordero

Luis Berenguer

En que momento se debe usar String en lugar de string?

Brother tengo la misma preguta... pero resulta que aquí es dificíl tener una respuesta por más que hablen de la "comunidad"

Segundo Juan

asi remplazamos el 'raw'?

porque en product.entity importamos SubDoc y SubDocSchema y no el CreateSubDocDto? oesa porque en el @Prop({type: }) usamos el Schema y no el DTO?

José Luis Cornejo Valencia

Hace un año

Relaciones embebidas en MongoDB: Se utilizan para estructurar datos de manera eficiente.
Tipado de documentos embebidos: Mejora la validación y la legibilidad del código.
1:1 embebidos: Se define un campo con un esquema específico.
1:N embebidos: Se puede tener un array de documentos embebidos.
Creación del esquema: Importar el esquema de subdocumento en la entidad principal.
DTOs: Permiten validar datos de entrada y mantener la integridad de los documentos embebidos.
Ejemplo de creación: Uso de POST para agregar productos con documentos embebidos.

Tipado de Documentos Embebidos en NestJS con Mongoose

Progreso del curso

Introducción

Database

Mongoose

Relaciones en MongoDB

Próximos pasos