Gestionar conexiones a la base de datos desde la API

Hola devs. Yo lo implementé de esta manera, elegí usar dotenv. Dotenv es una librería muy sencilla de implementar y garantiza una seguridad absoluta a la hora de trabajar con información sensible implementando variables de entorno. Sólo tienen que crear el archivo .env en la raíz del proyecto y añadir ahí sus variables de entorno, luego en el archivo server.js realizan la siguiente configuración y ya está. Luego añaden el archivo .env al gitignore y dejan un .env.example como buena prática

root/.env

DB_CONNECT = "mongodb+srv://<username>:<password>@cluster0.s5abe.mongodb.net/telegrom?retryWrites=true&w=majority"

root/server.js

const express = require("express");
const router = require("./network/routes");
const db = require("./db");
require("dotenv").config({ path: ".env" });

// conexion a la base de datos
db(process.env.DB_CONNECT);

const app = express();
const PORT = 3000;

//codificación
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

//cargamos el servidor a las rutas para que "prenda"
router(app);

app.use("/app", express.static("public"));

app.listen(PORT, () => {
  console.log(`La app está escuchando en http://localhost:${PORT}`);
});

Lo que hicimos en esta clase fue conectarnos a nuestra base de datos una vez se haya iniciado el servidor? antes se iniciaba la base de datos solo cuando nos ubicábamos en el componente “message”. Correcto? gracias.

¿Cuál es la ventaja de tener la URL de conexión de base de datos como parámetro? Quizás es mejor dejarla como variable de entorno. Pensando en qué tanto podría cambiar la URL de conexión entre métodos, es casi nunca. Sin embargo entre ambientes si cambia

No entiendo muy bien por qué basta con hacer db(‘credencialesDeMongo’); y no llamar a la función connect 😕

yo modifiqué un poco el código para que si la conexión falla el servicio no se levante

const db = require('mongoose');
db.Promise = global.Promise;

const connect = async (url) => {
      await db.connect(url,{
            useNewUrlParser:true,
            useUnifiedTopology: true
      })
            .then(() => {
                  console.log('[Date Base Connect] DB conectada con éxito');
            })
            .catch(err => {
                  console.error('[Date Base Connect] Error al conectar a la base de datoss'+err);
                  return process.exit(22);
            });
}

opcional mente también cambie server.js

db(uri2)
      .then(()=>{
            let app = express();

            app.use(bodyParser.json());
            app.use(bodyParser.urlencoded({extended: false}));

            router(app);
            app.listen(port);

            console.log('La aplicacion esta escuchando en el puerto: '+ port);
      })
      .catch(err => console.error(err));

esto a diferencia de lo que tiene el profesor en la clase es que primero da la conexión a la BD y luego levanta el servicio, y si la conexión falla el servicio no se levanta eso para prevenir que el servicio se levante y no tenga donde guardar. No se que tan bueno es mi código fue por practica ojala me puedan dar su opinión.

Todo esto está muy bien, espero que node tenga un framework con una estructura de trabajo ya más estructurada como Laravel en PHP.

muy buen curso 😉

Yo le agregué gestión de excepciones:

Esta clase esta en una posición que no es correcta, por favor corrijan el orden de las clases.

Así lo implemente yo, aclaro que estoy usando mongo en local.
db/mongo.js

const db = require("mongoose");

let uri = "mongodb://localhost:27017/Message";
db.Promise = global.Promise;

db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log("[db] Conectada con éxito"))
  .catch((err) => console.error("[db]", err));

server.js

const express = require("express")
const route = require("./network/routes")
const bodyParser = require("body-parser")
const morgan = require("morgan")

//db
require("./db/mongo")

No entiendo a qué se refiere cuando dice “compartir al conexión… para evitar llenar el pool de conexiones” 😦

Otra manera para mayor orden es lo siguiente, (ya que no me había quedado claro que el db(‘parm’) de server.js se asociaba con la única función existente en db.js)

En server.js
db.connect(“mongodb+srv://user:[email protected]/Chat”)

En db.js
async function conectar(url){
await db.connect(url,{
useNewUrlParser: true,
useUnifiedTopology: true
})

console.log([db] conectada con éxito)
}

async function desconectar(url){
Código para desconectar
console.log([db] Desconectada con éxito)
}

module.exports = {
connect : conectar,
disconect : desconectar
}

Es una buena práctica tener un archivo de enviroment (.env) donde este toda nuestra información de conexión para no dejarla expuesta en nuestro código

.env

//CONFIG
DB_USER=<username>
DB_PASSWORD=<password>
DB_HOST=<hostname>
DB_NAME=<databasename>

vamos a crear un archivo donde se podra tener toda la conexión con la base de datos llamada db.js en la raiz del directorio

db.js

const db = require('mongoose');
require('dotenv').config();
db.Promise = global.Promise;

async function connect(url) {
    await db.connect(url, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log("[db] Conectada con éxito");
}

module.exports = connect;

finalmente llamamos a la conexión desde el server.js
server.js

const db = require('./db');
// url de conexión con datos desde el archivo .env
const url_db = `mongodb+srv://${process.env.DB_USER}:${process.env.DB_PASSWORD}@${process.env.DB_HOST}/${process.env.DB_NAME}?retryWrites=true&w=majority`;

db(url_db);

Me encanta como se emociona el profesor, asi mismo te transmite la emocion. Por eso es importante dedicarse a un oficio que amemmos

Este curso me gusta mucho aquí les dejo la manera en como lo estoy hasta ahora haciendo, saludos…
https://github.com/luislozad/app-socket

Código ES

import db from "mongoose";

db.Promise = global.Promise;

async function connect(url) {
    try {
        await db.connect(url,{
            useNewUrlParser:true,
            useUnifiedTopology:true,
        });
        console.log('[db connection] Conectada con éxito');
    } catch (e) {
        console.error('[db connection] Connection failed', e.message)
    }
}

export default connect;

Este curso esta resolviendo demasiadas duda que tenia. En serio, muchas gracias

Pueden trabajar con las variables de entorno para hacer de la url de la base de datos mas segura. Es decir, hacer un archivo . env y ahí agregar la URL, luego hacer el llamado en db.js. Se puede usar el operador ternario “?:” para darle una condición y ya se hace un poco más seguro

Primero agregar en el archivo .env lo siguiente:

MONGODB_URL='mongodb+srv://usuario:RFabcdefghijklmnopq5@cluster0.h6s7a.mongodb.net/prueba'

Luego hacen el llamado en la base de datos: (Lo bueno de esto es que si existe, pues la va a usar y si no la crea ya que es la manera que trabaja una db no relacional, por eso es bueno el mongoose)

const URL = process.env.MONGODB_URL 
? process.env.MONGODB_URI
: 'mongodb://localhost/databasetest';

Espero darme a entender. Éxitos a tod@s!!

Hola alguien tendrá los pasos de la creación de conexión,no esta el vídeo 😦

Tengo una app realizada en Next.js en localhost:300/ no habrá ningún problema si tengo las rutas de node de la api en el mismo server es decir. localhost:300/usuarios

db.js

const db = require('mongoose')

db.Promise = global.Promise
//mongodb+srv://db_user_backend_node:<password>@cluster0-icc7n.mongodb.net/backendnode_db?retryWrites=true&w=majority

async function connect(url) {
    await db.connect(url, {
        useNewUrlParser: true,
        useUnifiedTopology: true,
    }).then(() => {
        console.log(' [db] Conectada con exito')
    }).catch( error => console.error(error))
}

module.exports = connect;```

server.js

const express = require('express')
const bodyParser = require('body-parser')

const db = require('./db')

const router = require('./network/routes')

db('mongodb+srv://db_user_backend_node:<password>@cluster0-icc7n.mongodb.net/backendnode_db?retryWrites=true&w=majority')
var app = express()
app.use(bodyParser.json()) 
app.use(bodyParser.urlencoded({extended: false}))


router(app)



app.use('/app', express.static('public'))

app.listen(3000) 
    console.log('La app esta escuchando en http://localhost:3000')```

store.js

const Model = require('./model')

function addMessage(message) {
    const myMessage = new Model(message)
    myMessage.save()
    
}

async function getMessages(filterUser) {
    let filter = {}
    if (filterUser !== null) {
        filter = { user: filterUser }
    }
    const messages = await Model.find(filter)
    return messages  
}

function removeMessage(id) {
    return Model.deleteOne({
        _id: id
    })
}

async function updateText(id, message) {
    const foundMessage = await Model.findOne({
        _id: id
    })
    foundMessage.message = message
    const newMessage = await foundMessage.save()
    return newMessage
}

module.exports = {
    add: addMessage,
    list: getMessages,
    updateText: updateText,
    remove: removeMessage,
}```

Compartir la conexión

Disculpen por la pregunta ¿Qué es una API? A veces creo saber pero no estoy seguro 🤔

creo que por seguridad deberiamos usar un archivo .env para las credenciales de la conexion a mongo

sip 😃 nos vemos

Antes de escalar nuestra arquitectura debemos observar la manera en que realizamos la conexion a la base de datos(DB).

Hay varias formas de gestionar las conexiones a la DB:
1-Crear una conexion que se abre y se cierra en cada peticion: Es una buena idea si tenemos muy pocas peticiones y no sabemos cuando llegaran.
2-Compartir la conexion:Cuando sabemos que tendremos una api donde haremos peticiones constantes.

Hola Devs:
-Aca les traigo mi solucion usando TypeScript:
Conexion a la base de datos de MongoDB:

-Aqui tienen el commit exacto de esta clase: Click Aqui
Recuerda, #NuncaParesDeAprender 💚

Práctica:
No me funciona correctamente, pero al menos lo intento. :p