Creacion API con NodeJs, mongoose y express

La actual API REST con Node, Express y Mongoose…

Observa por favor con atención esta aplicación…

• La aplicación hace el llamado a diferentes modulos para su correcto funcionamiento.

• Tiene un enrutador que se encarga de llamar a la función adecuada dependiendo del tipo de petición que se realice. Estas peticiones hacen referencia a las operaciones CRUD (Create, Read, Update, Delete).

• El controlador se encarga de procesar la petición en cada caso (listall, create, show, update, deleted) y obtener una respuesta y en cada caso responde con un mensaje o un objeto JSON, como corresponda.

• El archivo de configuración es necesario para establecer variables de entorno, en este caso, el puerto y la dirección de la base de datos a usar.

• Por último, el archivo db.js se encarga de la conexión con la base de datos.

• También se incluyen otros módulos importantes como bodyParser, que nos permite manejar peticiones y enviar respuestas en formato JSON y errorHandler, que nos permitirá manejar errores en nuestro servidor.

Primero cambié los nombres de algunos archivos para hacerlos más descriptivos y dev friendly.

./app/app.js

• Para este archivo instalé errorhandle

const express = require('express');
const bodyParser = require('body-parser');
const errorHandler = require('errorhandler'); // importar el middleware errorHandlerconst app = express();
const Product = require('./routes/prodRoutes');

//Nos permite manejar peticiones y enviar respuesta en formato json
app.use(bodyParser.json());
//De esta manera indicamos que no vamos a recibir peticiones enviadas directamente de un formulario, sino que sera todo enviado en json
app.use(bodyParser.urlencoded({extended: false}));

app.use(errorHandler()); // Agregar el middleware errorHandler
app.use('/prodRoutes', Product);

module.exports = app;

./app/config/config.js

• Aquí cambié la ruta del localhost

module.exports = {
    PORT: process.env.PORT || 3000,
    DB: process.env.DB || 'mongodb://localhost:27017/db'
}

./app/config/db.js

• En este archivo tuve muchos problemas con el método useCreateIndex: true, así que lo eliminé e igualmente funciona la API.

const mongoose = require('mongoose');
mongoose.set('strictQuery', false);
const CONFIG = require('./config');

module.exports = {
    connection: null,
    connect: function() {
        if (this.connection) returnthis.connection;
        return mongoose.connect(CONFIG.DB, {
            useUnifiedTopology: true,
            useNewUrlParser: true,
//            useCreateIndex: true 
        }).then(connection => {
            this.connection = connection;
            console.log('Conexion a DB exitosa');
            return connection;
        }).catch(err => {
            console.log(err);
            throw err;
        })
    }
}

./app/controller/prodController.js

• En este archivo se cambiaron algunas partes de algunas funciones…

const Product = require('../models/prodModels');

functionlistall(req, res) {
    Product.find({})
        .then(prodModels => {
            if(prodModels.length) return res.status(200).send({prodModels})
            return res.status(204).send({message: 'NO CONTENT'});
        }).catch(err => res.status(500).send({err}))
}

functioncreate(req, res) {
    let product = new Product(req.body);
    product.save()
        .then(product => 
            res.status(201).send({product})
        ).catch(err => res.status(500).send({err}))
    
}

functionshow(req, res) {
    if (req.body.err) return res.status(500).send({err: req.body.err});
    if (!req.body.prodModels) return res.status(404).send({message: 'Not Found'});
    let prodModels = req.body.prodModels;
    return res.status(200).send({prodModels});
}

functionupdate(req, res) {
    if(req.body.err) return res.status(500).send({err: req.body.err});
    if(!req.body.prodModels) return res.status(404).send({message: 'Not Found'});
    let product = req.body.prodModels[0];
    product = Object.assign(product, req.body);
    product.save()
        .then(product => res.status(200).send({message: 'Product Updated', product})
    ).catch(err => res.status(500).send({err}))
}

functiondeleted(req, res) {
    if(req.body.err) return res.status(500).send({err: req.body.err});
    if(!req.body.prodModels) return res.status(404).send({message: 'Not Found'});
    req.body.prodModels[0].remove()
        .then(product => {
            res.status(200).send({message:'Product removed', product})
        }
        ).catch(err => res.status(500).send({err}));
}

functionfind(req, res, next){
    let query = {};
    query[req.params.key] = req.params.value
    Product.find(query).then(prodModels => {
        if(!prodModels.length) return next();
        req.body.prodModels = prodModels;
        return next();
    }).catch(error =>{ // corregido a error
        req.body.err = err; // corregido a error
        next();
    })
}

module.exports = {
    listall,
    show,
    create,
    update,
    deleted,
    find,
}

./app/models/prodModels.js
+

const mongoose = require('mongoose'); // se agrega la importación de mongooseconst ProductSchema = new mongoose.Schema({
    name: {
        type: String,
        unique: true,
        required: true
    },
    price: {
        type: Number,
        required: true
    },
    category: {
        type: String,
        required: true,
        enum:['Hogar', 'Cocina', 'Higiene']
    },
    stock: {
        type: Number,
        default: 10
    },
    date: {
        type: Date,
        default: Date.now()
    }
});

module.exports = mongoose.model('Product', ProductSchema);

./app/routes/prodRoutes.js

• Este archivo cambió drásticamente…

const express = require('express');
const prodController = require('../controller/prodController');
const router = express.Router();

router.get('/', prodController.listall); // aquí se cambió el nombre del método
router.post('/', prodController.create);
router.get('/:name', prodController.show);
router.put('/:name', prodController.update);
router.delete('/:name', prodController.deleted); // aquí se cambió el nombre del métodomodule.exports = router;

Y la respuesta de la consola es:

user@d-caldasCaridad:~/API-REST$ npm run dev

> [email protected] dev
> nodemon server.js
> [email protected] dev
> nodemon server.js

[nodemon] 2.0.20
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node server.js`
Servidor corriendo en el puerto: 3000
Conexion a DB exitosa

¿qué otros cambios se hicieron en la aplicación?

Se han hecho varias correcciones. Entre ella:

• En la definición de rutas del archivo ./app/routes/prodRoutes.js se han corregido los nombres de los métodos de delete y listAll para que se ajusten a los nombres de los métodos en el archivo ./app/controller/prodController.js.
• En el archivo ./app/controller/prodController.js, se ha corregido el nombre de la variable en la función catch en el método find.
• En el archivo ./app/config/db.js se ha corregido una letra en la propiedad useCreateIndex.
• Se han importado los módulos mongoose en el archivo ./app/models/prodModels.js y errorhandler en el archivo ./app/app.js.
• Se han agregado middleware de manejo de errores en el archivo ./app/app.js.
• Se han agregado las importaciones necesarias para correr la aplicación.