Conectando Mongo a los servicios

Curso de NestJS: Persistencia de Datos con MongoDB

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

No tienes acceso a esta clase

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

Si ya tienes una cuenta,

Recursos

Establecida la conexión a la base de datos con Mongoose y creadas las entidades que mapean la información, es momento de realizar las consultas a la base de datos desde los servicios.

Ejecutando consultas con Mongoose

Aquí tienes una serie de pasos que te ayudarán durante este proceso.

Paso 1: importación del esquema en los servicios

Comienza inyectando el esquema creado en el servicio que será el responsable de realizar las consultas.

// modules/products/products.service.ts
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';

@Injectable()
export class ProductsService {

  constructor(@InjectModel(Product.name) private productModel: Model<Product>) {}

  findAll() {
    return this.productModel.find().exec();
  }

  findOne(id: string) {
    return this.productModel.findById(id).exec();
  }
}

Utilizando InjectModel, inyectas el esquema de productos en el servicio de productos.

Paso 2: importación del servicio en los controladores

Los servicios son los responsables de realizar las consultas a la base de datos, pero los controladores son quienes determinan cuándo hay que realizar esas consultas.

// module/products/products.controller.ts
@Controller('products')
export class ProductsController {

  @Get()
  async getAll() {
    return await this.productsService.findAll();
  }

  @Get(':productId')
  async getOne(@Param('productId') productId: string) {
    return await this.productsService.findOne(productId);
  }
}

Crea tantos endpoints como necesites para responder a la necesidad de obtención de los datos a través de GET.
Así, ya tienes completada tu conexión a la base de datos y obtención de datos en tu API a través de Mongoose y sus esquemas.

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

Código de ejemplo para conectar Mongo a los servicios

// src/products/services/products.service.ts

import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';

...

@Injectable()
export class ProductsService {
  constructor(
    @InjectModel(Product.name) private productModel: Model<Product>, // 👈
  ) {}
  ...

  findAll() { // 👈
    return this.productModel.find().exec();
  }

  async findOne(id: string) {  // 👈
    const product = await this.productModel.findById(id).exec();
    if (!product) {
      throw new NotFoundException(`Product #${id} not found`);
    }
    return product;
  }
  ...

}

// src/products/controllers/products.controller.ts

@Controller('products')
export class ProductsController {
   ...

  @Get(':productId')
  getOne(@Param('productId') productId: string) {   // 👈
    return this.productsService.findOne(productId);
  }
}

// src/users/services/users.service.ts
@Injectable()
export class UsersService {
  ...

  async getOrderByUser(id: number) {   // 👈
    const user = this.findOne(id);
    return {
      date: new Date(),
      user,
      products: await this.productsService.findAll(),   // 👈 implement await
    };
  }
}

Aportes 6

Preguntas 4

Ordenar por:

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

Brian Yasier Jacobo Fuentes

hace 3 años

Dejo mi aporte de cómo a la vez tener el timestamps en true, en el Shema que quieras, me refiero al createdAt y updatedAt

@Schema({
  timestamps: true,
})

Jose Daniel Barría Reyes

hace 4 años

Dejo mi aporte de como me quedaron los entities del modulo de producto

Entities

// products/entities/brand.entity.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class Brand extends Document {
  @Prop({ required: true })
  name: string;

  @Prop()
  image: string;
}
export const BrandSchema = SchemaFactory.createForClass(Brand);

// products/entities/category.entity.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class Category extends Document {
  @Prop({ required: true })
  name: string;
}
export const CategorySchema = SchemaFactory.createForClass(Category);

Services

// products/services/brand.service.ts
@Injectable()
export class BrandsService {

  constructor(
    @InjectModel(Brand.name) private brandModel: Model<Brand>,
  ) {}

  findAll() {
    return this.brandModel.find().exec();
  }

  async findOne(id: string) {
    const brand = await this.brandModel.findById(id).exec();
    if (!brand) {
      throw new NotFoundException(`Brand #${id} not found`);
    }
    return brand;
  }
}

// products/services/categories.service.ts
@Injectable()
export class CategoriesService {

  constructor(
    @InjectModel(Category.name) private categoryModel: Model<Category>,
  ) {}

  findAll() {
    return this.categoryModel.find().exec();
  }

  async findOne(id: string) {
    const category = await this.categoryModel.findById(id).exec();

    if (!category) {
      throw new NotFoundException(`Category #${id} not found`);
    }
    return category;
  }
}

Controllers

// products/controllers/brand.controller.ts
@ApiTags('brands')
@Controller('brands')
export class BrandsController {
  constructor(private brandsService: BrandsService) {}

  @Get()
  findAll() {
    return this.brandsService.findAll();
  }

  @Get(':id')
  get(@Param('id') id: string) {
    return this.brandsService.findOne(id);
  }
}

// products/controllers/category.controller.ts
@Controller('categories')
export class CategoriesController {
  constructor(private categoriesService: CategoriesService) {}

  @Get()
  findAll() {
    return this.categoriesService.findAll();
  }

  @Get(':id')
  get(@Param('id') id: string) {
    return this.categoriesService.findOne(id);
  }
}

cristiandares

hace 3 años

Este curso vale oro. Está excelente

Andrés Esteban Rodríguez Jiménez

hace 2 años

Amo este curso uwu.

Juan Camilo Noreña López

hace 2 años

Aquí mi endpoint de user funcionando

Rony Porraz Vargas

hace 4 años

Estoy haciendo un api para un creador de paginas tipo wordpress con react y lo combine con esta api, asi quedo mi modelo

import { Injectable , Inject } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Page, PageDocument } from 'src/schema/page.schema';
import { CreatePageDTO } from '../dtos/page.dto';

@Injectable()
export class PageService {
  
  constructor(
    @InjectModel(Page.name) private pageModel: Model<PageDocument>,
  ) {}
  
  async createPage( page : CreatePageDTO ) {

    const result = await this.pageModel.findOne({ name: page.name })

    if( result ) return null

    return await new this.pageModel(page).save();

  }

  async getByName(name) {
    
    const doc = await this.pageModel.findOne({ name });
    
    return doc;

  }

  async getAllPages() {
    
    const doc = await this.pageModel.find({}, { name: 1 });
    
    return doc;

  }


  }
  
}