Implementando acciones CRUD en MongoDB

Clase 18 de 43 • Curso de Express.js 2018

Contenido del curso

Bienvenida e introducción

Template Engines y archivos estáticos

Creando un API Restful

Conectando Express.js con servicios externos

Middlewares: En el medio del request

Autenticación en Express.js

Testing

Deployment

Tomar examen

Carlos Martinez

student•

estuve viendo que cada vez que se hacia una acción CRUD se conectaba con el cliente de mongoDB, por lo que he leído no es recomendable conectarse tantas veces, sino hacer 1 sola conexión y mantener 1 instancia activa de mongoDB mientras el usuario esté activo, asi que por lo que ví en el curso de esenciales de nodejs en la cual el profesor Emir Salazar recomendaba 1 sola instancia, le hice modificaciones a el archivo donde nos conectamos a mongo, ahora solo se conecta 1 vez con mongo cuando arranca el index.js de la app y se mantiene la instancia. quedando asi el archivo mongo.js:

// carlos eduardo
// @carlosEdua -> github
// @cems -> platzi 
// standart class to connect, use and disconnect mongoDB with
// one instance 

const { MongoClient } = require("mongodb");
const { 
    dbName,
    dbUSer,
    dbPassword
} = require("../config/config");

const URI = `mongodb+srv://${dbUSer}:${dbPassword}@${dbName}-ydbgb.mongodb.net/test?retryWrites=true&w=majority`;

// *****  global instance of mongo  *****
let INSTANCE = null;
// **************************************

class MongoLib{
    constructor(){
        // crear un cliente de mongoDB, mas no conectarse aún
        this.client = new MongoClient(URI, { useNewUrlParser: true});
        this.dbName = dbName;
        this.instance = INSTANCE;
        this.db = INSTANCE ? INSTANCE.db(dbName) : null;
    }

    async connect(){
        try {
            // conectarse al cliente
            const clientConnected = await this.client.connect();
            // referenciar instancia
            this.instance = clientConnected;
            INSTANCE = clientConnected;
            // obtener la base de datos
            // this.db = await this.instance.db(this.dbName);
            console.log("base de datos conectada!!!");
            // return true for run the app
            return true;
        } catch (err) {
            return new Error(err)
        }
    }

    async disconnect(){
        try {
            if(this.instance) await this.instance.close();
        } catch (err) {
            return Error(err)
        }
    }

    // ===================   CRUD   ====================
    // ## create ##
    createOne(collection, query){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).insertOne(query);
    }

    createMany(collection, arr){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).insertMany(arr);
    }
    // ## find ##
    getAll(collection, query){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).find(query).toArray();    
    }

    getOne(collection, query){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).findOne(query);
    }
    // ## update ##
    updateOne(collection, query, newValue){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).updateOne(query, newValue);
    }

    updateMany(collection, query){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).updateMany(query);
    }
    // ## delete ##
    deleteOne(collection, query){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).deleteOne(query);
    }

    deleteMany(collection, query){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).deleteMany(query);
    }
    // ## drop ##
    dropCollection(collection){
        const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).drop();
    }

}

module.exports = MongoLib;

en la carpeta services el archivo products.js quedaría asi:

// script para comunicarse con las librerías de BDD y mandarselo
// al controlador
// aqui se controla la logica de negocio para los productos
// tal como: crear, pedir, actualizar y borrar

const MongoLib = require("../mongo/mongo");
const { ObjectID } = require("mongodb");

class productService{
    constructor(collection){
        this.mongo = new MongoLib();
        this.collection = collection;
    }
    // ==================   get products  ==================
    async getProducts({tags, productName}){
        // ver si se busca por tags o productName y en caso de no tener
        // asignar un objeto vacio
        const byTags = tags ? { tags : { $in: JSON.parse(tags) }} : null;
        const byName = productName ? { productName: new RegExp(productName)} : null;
        const query = (byTags || byName) || {};

        const products = await this.mongo.getAll(this.collection, query);
        return products;
    }

    async getProduct(id){
        const ID = new ObjectID(id); 
        const product = await this.mongo.getOne(this.collection, { _id: ID});
        return product;
    }

    // ====================  create products  ===================
    async createProduct({ body }){
        const productCreated = await this.mongo.createOne(this.collection, body);
        return productCreated;
    }
    
    // ====================  update products  ===================
    async updateOneProduct(id, newValues){
        const ID = new ObjectID(id);
        // por si se actualiza más de 1 campo
        let newValuesObject = {};
        for( let key in newValues){
            newValuesObject[key] = newValues[key];
        }
        const productUpdated = await this.mongo.updateOne(
            this.collection, { _id: ID }, { $set: newValuesObject}
            );
        return productUpdated;
    }

    // =================  remove products  ==================
    async removeProduct(id){
        const ID = new ObjectID(id);
        const productDeleted = await this.mongo.deleteOne(this.collection, { _id: ID});
        return productDeleted;
    }


}

module.exports = productService;

y las rutas de la API la tengo asi:

const router = require("express").Router();
const ProductServices = require("../../services/products");


// get all products
router.get("/", async (req, res, next ) => {
    // nueva instancia de los servicios para comunicarse
    // con la instancia ya creada de mongoDB
    const productServices = new ProductServices("products");
    const { tags, productName } = req.query;
    try {
        const products = await productServices.getProducts({tags, productName});
        res.send(products);
    } catch (err) {
        next(err);
    }
})

// get one product
router.get("/:productId", async (req, res, next ) => {
    const { productId } = req.params;
    const productServices = new ProductServices("products");
    try {
        const products = await productServices.getProduct(productId);
        res.send(products);
    } catch (err) {
        next(err);
    }
})

// create a product
router.post("/", async (req, res, next ) => {
    const productServices = new ProductServices("products");
    const  product = req.body;
    try {
        const productCreated = await productServices.createProduct({body: product});
        res.send(productCreated);
    } catch (err) {
        next(err);
    }
})

// update a product
router.put("/:productId", async (req, res, next ) => {
    const productServices = new ProductServices("products");
    const newProductValues = req.body;
    const { productId } = req.params;
    try {
        const productUpdated = await productServices.updateOneProduct(productId, newProductValues);
        res.send(productUpdated);
    } catch (err) {
        next(err);
    }
})

// delete a product
router.delete("/:productId", async (req, res, next ) => {
    const productServices = new ProductServices("products");
    const { productId } = req.params;
    try {
        const productErased = await productServices.removeProduct(productId);
        res.send(productErased);
    } catch (err) {
        next(err);
    }
})

module.exports = router;

por ultimo el index.js queda de la siguiente manera:

const express = require("express");
const hbs = require("express-handlebars");
const viewRoutes = require("./routes/views/products");
const apiRoutes = require("./routes/api/productsApi");
const path = require("path");
const MongoLib = require("./mongo/mongo");
// app
const app = express();
const mongo = new MongoLib();
// middlewares
app.use(express.json());

// set view engine
app.engine('hbs', hbs({
    extname: 'hbs', 
    defaultLayout: "index.hbs",
    layoutsDir: path.join(__dirname, 'views/'),
    partialsDir  : [
        //  path to your partials
        path.join(__dirname, 'views/partials'),
    ]
}));
app.set("views", "./views");
app.set("view engine", "hbs");
// routes
app.use("/products", viewRoutes);
app.use("/api/products", apiRoutes);
// redirect
app.use("/", (req,res) => {
    res.redirect("/products");
})

// run the server
function run(){
    app.listen( process.env.PORT || 4500, () => {
        console.log("server created");
    })
}
// iniciar conexión con mongoDB e iniciar servidor si
// la conexión fué exitosa 
mongo.connect()
    .then( () => {
        run();
        // desconectar mongoDB si se cierra el programa
        process.on("SIGINT", mongo.disconnect);
        process.on("SIGTERM", mongo.disconnect);
    })
    .catch( err => console.log("DB not connected ", err));

creo que es una mejor implementación pero eso ya depende del proyecto y de cada quien.

Arantxa Giovanna Rosas Del Valle

student•

No me funciona la parte de

 const {instance, dbName} = this;
        return instance.db(dbName).collection(collection).insertOne(query);

Me marca que this.instance es null, ¿sabrás por qué?

Luis Lira

jorge llanque

Héctor Martínez Reséndiz

Luis Chavez

Sebastian Kloster

Francisco Ponce

Jorge Méndez Ortega

Carlos Acevedo

Diego Hernán Moreno Amaya

Antonio Gámiz Delgado

Kevin Alberto Márquez Rodríguez

Mario Alejandro Cortez Salinas

Juan Rodrigo de la Cruz García García Briseño

Guillermo Rodas

teacher•

Luis Avila

Juan Castro

Armando De La Vega

Alejandro González Reyes

Luis Gerardo López Hernández

Victor Lozada

Diego Forero

Team Platzi•

Nathaly Stefani Riaño Bejarano

Danniel Sequera

JAIME URQUIZU

JAVIER SANTIAGO SALGADO

Juan David González Rodríguez

Benjamin Cruz

Fernando Cordero

Pedro Alberto Barrios Molina

Antonio Luis Gil Rodríguez

fernando josé pineda trujillo

Diego Esteban Cortés Escandón

Implementando acciones CRUD en MongoDB

Bienvenida e introducción

¿Dónde aprender Express.js actualizado?

Lo que aprenderás sobre Express.js

¿Qué es express y para qué sirve?

Creando tu primer servidor

Express application generator

Template Engines y archivos estáticos

Qué es template engine y cómo crearlo

Implementando un template engine

Usando Pug como template engine

Usando Handlebars como template engine

Creando nuestro layout de productos usando Pug

Manejo de archivos estáticos

Creando un API Restful

Anatomía de una API RESTful e implementación CRUD

Implementando nuestra capa de Servicios

Recapitulando el proyecto

Request object

Conectando Express.js con servicios externos

Conexión a Mongodb en Express.js

Conectando nuestros servicios con mongo DB