Tipado de Documentos Embebidos en NestJS con Mongoose

Clase 21 de 24 • Curso de NestJS: Persistencia de Datos con MongoDB

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í:

Comentarios

Nicolas Molina

teacher•

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

Josué Eliezer Gómez Soto

student•

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

Josué Eliezer Gómez Soto

student•

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

name: String; vs name string;

Ivonne lizeth Tarapués Rodríguez

student•

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

student•

Excelente aporte! Muchas gracias!

Fernando Cordero

student•

Les dejo el codigo para la solucion de la clase anterior:

// src/users/entities/skills.entity.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Skill {
  @Prop()
  name: string;
  @Prop()
  color: string;
}
export const SkillSchema = SchemaFactory.createForClass(Skill);

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

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

  @IsString()
  @IsNotEmpty()
  readonly color: string;
}
export class UpdateSkillDto extends PartialType(CreateSkillDto) {}

Implementacion en el dto de customers

import { CreateSkillDto } from './skills.dto';
export class CreateCustomerDto {
  ...
  @IsArray()
  @IsNotEmpty()
  @ValidateNested({ each: true })
  @Type(() => CreateSkillDto)
  readonly skills: CreateSkillDto[];
}

y en la entidad de customers

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document, Types } from 'mongoose';
import { Skill, SkillSchema } from './skills.entity';

@Schema()
export class Customer extends Document {
  @Prop({ required: true, type: String })
  name: string;
  @Prop({ required: true, type: String })
  email: string;
  @Prop({
    type: [SkillSchema],
  })
  skills: Types.Array<Skill>;
}
export const CustomerSchema = SchemaFactory.createForClass(Customer);

Luis Berenguer

student•

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

Josué Eliezer Gómez Soto

student•

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

student•

asi remplazamos el 'raw'?

Segundo Juan

student•

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?

Josué Eliezer Gómez Soto

student•

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);

José Luis Cornejo Valencia

student•

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.

// 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);

// 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) {}

// 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)
}
...

// 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
}

// src/users/entities/skills.entity.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Skill {
  @Prop()
  name: string;
  @Prop()
  color: string;
}
export const SkillSchema = SchemaFactory.createForClass(Skill);

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

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

  @IsString()
  @IsNotEmpty()
  readonly color: string;
}
export class UpdateSkillDto extends PartialType(CreateSkillDto) {}

import { CreateSkillDto } from './skills.dto';
export class CreateCustomerDto {
  ...
  @IsArray()
  @IsNotEmpty()
  @ValidateNested({ each: true })
  @Type(() => CreateSkillDto)
  readonly skills: CreateSkillDto[];
}

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document, Types } from 'mongoose';
import { Skill, SkillSchema } from './skills.entity';

@Schema()
export class Customer extends Document {
  @Prop({ required: true, type: String })
  name: string;
  @Prop({ required: true, type: String })
  email: string;
  @Prop({
    type: [SkillSchema],
  })
  skills: Types.Array<Skill>;
}
export const CustomerSchema = SchemaFactory.createForClass(Customer);

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);

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) {}

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);

Tipado de Documentos Embebidos en NestJS con Mongoose

Introducción

Persistencia de Datos con MongoDB y NestJS

Instalación de Docker en Windows, macOS y Ubuntu

Creación de Tienda Online con MongoDB y Docker

Database

Configuración y ejecución de MongoDB con Docker Compose

Conexión a Base de Datos MongoDB con Mongo Compass

Instalación y conexión de MongoDB en Node con driver oficial

Inyección de Conexiones MongoDB en Servicios NestJS

Consultas a MongoDB con Nest.js: Implementación de Endpoints

Variables de Entorno para Configuración de MongoDB en Node.js

Mongoose

Instalación y Configuración de Mongoose con NestJS

Definición de Esquemas en Mongoose para eCommerce con NestJS

Operaciones CRUD con MongoDB y Node.js en un Servicio de Productos

Creación, actualización y eliminación de productos en MongoDB

Validación de MongoID con Pipes en NestJS

Paginación en MongoDB con DTOs y Validaciones en NestJS

Consultas Avanzadas con Rangos de Precios en MongoDB

Indexación en MongoDB: Cómo optimizar consultas rápidas

Relaciones en MongoDB

Relaciones embebidas en MongoDB: Manejo y ejemplos prácticos

Relaciones uno a uno referenciadas en MongoDB

Relaciones Uno a Muchos en MongoDB: Arrays Embebidos vs Referenciados

Tipado de Documentos Embebidos en NestJS con Mongoose

Relaciones Uno a Muchos Referenciadas en MongoDB

Manipulación de Arrays en E-commerce: Métodos y Endpoints

Próximos pasos

Autenticación con Mongo y Passport GS en Nest.js