Configuración de base de datos

Clase 8 de 25 • Curso Práctico de GraphQL con JavaScript

Resumen

Por el momento nuestra API maneja pura información estática, vamos a cambiar esto pasando la información a una base de datos, en este caso usaremos MongoDB.

Es recomendable almacenar las credenciales de conexión a la base de datos como variables de entorno del sistema y utilizar dotenv para la lectura de dichas credenciales. Para su instalación vamos a correr el comando

npm i dotenv

Comentarios

Edinson Padrón

student•

Creen una cuenta en MongoDB Atlas
Creen un nuevo cluster
En el nuevo cluster, hagan click en Connect 3.1) Coloquen en lista blanca su IP 3.2) Creen un usuario para la BD con su contraseña 3.3) Creen un nuevo enlace de conexión
En robot3t hagan click en Create en la ventana MongoDB Connections 4.1) Peguen el enlace de conexión generado en (3.2) 4.2) Hagan click en From SRV
Hagan click en Connect en la ventana MongoDB Connections

Andres Felipe Jerez Giraldo

student•

O sean aun mas independientes y utilicen todo el poder de herramientas como docker, se hacen un compose con volumenes y no sufren con todo eso y todos felices

silvana murgo

student•

Mil gracias!

Leonardo Casallas Beltran

student•

Para las versiones actuales se instala es mongodb

npm install mongodb

Luego el archivo de conexión queda de la siguiente manera:

const { MongoClient } = require('mongodb');

const { DB_USER, DB_PASSWORD, DB_HOST, DB_NAME } = process.env;

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}?retryWrites=true&amp;w=majority`;
let connection;

async function connectDB() {
  if (connection) return connection;

  let client;
  try {
    client = new MongoClient(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    connection = await client.connect();
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error);
    process.exit(1);
  }

  return connection;
}

module.exports = connectDB;

Jhon Manuel Angulo Moncada

student•

MLAB ya no esta disponible, ahora se usa Mongo Atlas

aqui el codigo de db.js para atlas

'use strict'

const MongoClient = require('mongodb').MongoClient

const {
    DB_USER,
    DB_PASSWD,
    DB_HOST,
    DB_PORT,
    DB_NAME
} = process.env

const uri = `mongodb+srv://${DB_USER}:${DB_PASSWD}@test-qgluq.mongodb.net/test?retryWhites=true&w=majority`


let connection

async function connectDB() {
    if (connection) return connection
    let client
    
    try {
        client = await MongoClient.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
        connection = client.db(DB_NAME)
    } catch (error) {
        console.log('No se pudo conectar a la base de datos de mongo', uri, error)
        process.exit(1)        
    }
    return connection
}

module.exports = connectDB

Freddy Córdova Arana

student•

Muchas gracias, de gran ayuda para los que estamos siguiendo el curso con MongoDB Atlas

Cesar David Ramírez Dimaté

student•

¿Qué significa retryWhites=true&w=majority?

Andres Alba

student•

De esta clase en adelante empiezan los problemas por usar tecnologías obsoletas. Ojalá cambien este curso para Mongo Atlas y poderlo seguir sin problemas.

Cesar David Ramírez Dimaté

student•

De igual manera, como ingeniero, no deberías quedarte varado por este cosas... y no amerita cambiar un curso completo sólo por una tecnología....

Reinaldo Mendoza

student•

Tenemos que buscar soluciones, igual si lo actualizan manana va a haber algo nuevo, es mejor aprender como solucionarlo en vez aprender a hacerlo de forma estatica

Armando Reyes Perez

student•

Para los que estan viendo este curso en este año 2020, EFECTIVAMENTE tienes que crear una cuenta con atlas y el administrador cambia, solo deben de crear un user, en la parte de connect te da la liga de como conectarte desde node.js. NOTA: deben de agregar su IP en network access, o pueden poner publica su base de datos, poniendole IP 0.0.0.0 para tener acceso desde cualquier lado.

Cesar David Ramírez Dimaté

student•

De hecho yo agregué a la lista de direcciones mi IP pública en Network Access

Esteban Ciudad

student•

hubo una confusión por parte del profesor, se debe utilizar mongodb para acceder a MongoClient:

npm i mongodb

Freddy Córdova Arana

student•

Importante ☝

Cesar David Ramírez Dimaté

student•

Esto si es grave jajaja.

David Behar

student•

Yo preferí crearme un archivo llamado config.js mismo que accede a mis variables de entorno:

require('dotenv').config()

const db = {
  port: process.env.DB_PORT || 27017,
  username: process.env.DB_USERNAME,
  password: process.env.DB_PASSWORD,
  cluster: process.env.DB_CLUSTER,
  name: process.env.DB_NAME
}

module.exports = {
  db
}

Juan Jose Vega

student•

David podrías compartir cómo lo hiciste con github

David Behar

student•

No lo había subido, pero ya lo dejé acá https://github.com/behagoras/course-graphql

Erick Daniel Pérez Mata

student•

En este curso se explica tambien como conectarse a mongo desde node

https://platzi.com/clases/1646-backend-nodejs/22033-creacion-de-una-bd-en-mongoatlas/

silvana murgo

student•

gracias @EPadronu23 dejo los pasos para ubuntu.

1 -Creen una cuenta en MongoDB Atlashttps://cloud.mongodb.com/ y generen un nuevo cluster 2- En el nuevo cluster, hagan click en Connect 3- Coloquen en lista blanca su IP 5- Creen un usuario para la BD con su contraseña 5- Seleccionen la opcion "connect your aplication" 6- Copien la cadena de conexion 7- Vayan a collections y agreguen una base de datos name: platzi collection: courses

(De igual manera el mismo sistema los va guiando)

Por otro lado descarguen robot3t https://angelcruz.dev/post/instalar-robo-3t-formerly-robomongo-en-ubuntu-1804 1- En robot3t hagan click en Create en la ventana MongoDB Connections 2- Peguen la cadena de conexion copiada anteriormente (reemplacen las variables <>) en el input al lado de FROM SRV 3) Hagan click en From SRV 4) Click en test connection 5) Si todo salio bien click en Save

Listo!

Patricio Pilco

student•

No se puede seguir !!! Debe existir actualización del curso o mas bien quitarla. Las personas necesitan aprender no perder su tiempo.

Carlos Alberto Morales Heras

company_admin•

DIfiero un poco, a veces es bueno ese tipo de cosas para toparte con problemas y resolverlos y asi aprendes mas.

Cesar David Ramírez Dimaté

student•

Más bien te queda grande entrar a revisar y configurar cuando cambian algunas versiones. El curso en sí es de GraphQL no de MongoDB... por eso el profesor decía que vieras ese curso antes, sino, no estarías haciendo este tipo de reclamos...

Alexander Silvera

student•

Una consulta no es mejor utilizar Compas para usar MongoDB??

Adrian Estrada

teacher•

es otra muy buena opción

David Gallego

student•

creo que Robo3T es un cliente mas ligero en comparacion a Compass pero igual todos 2 son recomendados

Ernesto Vizcaíno Alvarado

student•

Como encuentro mi host y port en mongo atlas?

Edwin García

student•

En su cluster puede ver este botón

Que abre esta ventana en la que elegimos esta opción

Y eso nos muestra una url de conexión parecida a la que usa el profesor, debe usar esta en lugar de la del profesor y el host es el que puse en el cuadro rojo, puerto no se necesita

Edwin García

student•

En esa url tiene que cambiar test por el nombre de la base de datos

Fernando Azuaje

student•

El metodo connect no se encuentra en el paquete de mongo, es de mongodb asi que deben instalarlo para que funcione

Daniel Alberto Esquinazi

student•

Con mongodb hice la conexión de la siguiente forma:

const { MongoClient } = require('mongodb')

async function connectDb() {
  if (db) return db

  let client = new MongoClient(
    mongoUrl,
    { useNewUrlParser: true }
  );

  try {
    await client.connect();
    db = client.db(DB_NAME);
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error)
    process.exit(1)
  }

  return db;
}

Yank Carlos Reyes Espinal

student•

Sin miedo a equivocarme, creo que sin duda alguna podría decir que este es uno de los mejores profesores que tiene Platzi.

Alejandro Sebastian Dubon Estrada

student•

Otra forma de conectarse a mongo con la libreria mongoose . Visto en el curso de NodeJS

const mongoose = require('mongoose');
const { DB_USER, DB_PASS, DB_NAME } = process.env;

const uri = `mongodb+srv://${DB_USER}:${DB_PASS}@cluster0.pjeso.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;
mongoose.Promise = global.Promise;

async function connectDB() {
    await mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true})
        .then(() => {
            console.log('[database] conectada con exito')
        }).catch((e) => {
            console.error('Hubo un error al conectarse con la DB');
            console.error(e);
        });
}

module.exports = connectDB;```

Esteban Ciudad

student•

Al momento de estrenarse el curso ya no se encuentra disponible el registro directo para mLab, ya que este fue adquirido por MongoDB y por lo tanto toca usar MongoDB Atlas, funciona muy bien y sirve de igual manera para seguir el curso, si tienes alguna problema al configurarlo coméntalo y te podemos ayudar.

Cesar David Ramírez Dimaté

student•

Esa es la actitud, en vez de decir que actualicen el curso o hasta acá fue todo.

andrés eduardo betancourt bescanza

student•

Muchachos les recomiendo que sigan este video para la creacion de la base de datos en mongo atlas https://www.youtube.com/watch?v=_irNiugD180

Guerin Steven Colocho Chacón

student•

Lo pueden hacer tambien con mongoose: npm i mongoose

'use strict'
const db = require('mongoose');

const {
    DB_USER,
    DB_PASSWD,
    DB_NAME
} = process.env

const mongoURL = `mongodb+srv://${DB_USER}:${DB_PASSWD}@cluster0.zptt6.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;


async function connect() {

    await db.connect(mongoURL, {
        useUnifiedTopology: true,
        useNewUrlParser: true
    })
    console.log('[db] conectada con exito')
}


module.exports = connect

Juan Guillermo Poblete Bazaes

student•

Solo de forma local

Si tienen docker instalado y no quieren crearse otra cuenta les puedo recomendar

En la raíz de su proyecto le dan a crear archivo este se debe llamar docker-compose.yml
Copien este contenido dentro

version: '3.7'
services:
  mongodb_container:
    image: mongo:latest
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: rootpassword
    ports:
      - 27017:27017
    volumes:
      - mongodb_data_container:/data/db

volumes:
  mongodb_data_container:

En su terminal ir a donde este creado el nuevo archivo EJ:

C:\Users\Asus\platzi-courses\graphql\platzi-graphql

Ejecutar el comando

docker-compose up -d

esto les va a generar una instancia docker con mongodb

Cadena de conexion: mongodb://localhost:27017/test
user: root
password: rootpassword La ventaja es que para otro proyecto pueden usar lo mismo y cuando dejen de usar solo van y borran el contenedor

Juan Antonio Cuahonte Isla

student•

Yo tuve que hacerlo así

Enero de 2022

'use strict'
const { config } = require('dotenv');
// Recordar instalar MongoDB
// npm i mongodb
// para poder utilizar MongoClient
const { MongoClient } = require('mongodb');

const {
    DB_URL
} = process.env

let connection;

async function connectDB(){
    if(connection){
        return connection;
    }        

    connection = new Promise(async(resolve,reject) => {
        
        try {
            let dbConnection;
            let courses;

            // Creo un new MongoClient
            const client = new MongoClient(`${DB_URL}`);
            // Conecto el client al server
            await client.connect();
            // Establesco la conexión a la base de datos
            dbConnection = await client.db("node_graphql_course_db");
	    // Resuelvo con la dbConnection
            resolve(dbConnection);
        } catch (error) {
            reject(error);
        }
    });

   // Regreso la Promise que emplearé para conectar mi DB
    return connection;
}

module.exports = connectDB;

const { MongoClient } = require('mongodb');

const { DB_USER, DB_PASSWORD, DB_HOST, DB_NAME } = process.env;

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}?retryWrites=true&amp;w=majority`;
let connection;

async function connectDB() {
  if (connection) return connection;

  let client;
  try {
    client = new MongoClient(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    connection = await client.connect();
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error);
    process.exit(1);
  }

  return connection;
}

module.exports = connectDB;

'use strict'

const MongoClient = require('mongodb').MongoClient

const {
    DB_USER,
    DB_PASSWD,
    DB_HOST,
    DB_PORT,
    DB_NAME
} = process.env

const uri = `mongodb+srv://${DB_USER}:${DB_PASSWD}@test-qgluq.mongodb.net/test?retryWhites=true&w=majority`


let connection

async function connectDB() {
    if (connection) return connection
    let client
    
    try {
        client = await MongoClient.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
        connection = client.db(DB_NAME)
    } catch (error) {
        console.log('No se pudo conectar a la base de datos de mongo', uri, error)
        process.exit(1)        
    }
    return connection
}

module.exports = connectDB

require('dotenv').config()

const db = {
  port: process.env.DB_PORT || 27017,
  username: process.env.DB_USERNAME,
  password: process.env.DB_PASSWORD,
  cluster: process.env.DB_CLUSTER,
  name: process.env.DB_NAME
}

module.exports = {
  db
}

const { MongoClient } = require('mongodb')

async function connectDb() {
  if (db) return db

  let client = new MongoClient(
    mongoUrl,
    { useNewUrlParser: true }
  );

  try {
    await client.connect();
    db = client.db(DB_NAME);
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error)
    process.exit(1)
  }

  return db;
}

const mongoose = require('mongoose');
const { DB_USER, DB_PASS, DB_NAME } = process.env;

const uri = `mongodb+srv://${DB_USER}:${DB_PASS}@cluster0.pjeso.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;
mongoose.Promise = global.Promise;

async function connectDB() {
    await mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true})
        .then(() => {
            console.log('[database] conectada con exito')
        }).catch((e) => {
            console.error('Hubo un error al conectarse con la DB');
            console.error(e);
        });
}

module.exports = connectDB;```

'use strict'
const db = require('mongoose');

const {
    DB_USER,
    DB_PASSWD,
    DB_NAME
} = process.env

const mongoURL = `mongodb+srv://${DB_USER}:${DB_PASSWD}@cluster0.zptt6.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;


async function connect() {

    await db.connect(mongoURL, {
        useUnifiedTopology: true,
        useNewUrlParser: true
    })
    console.log('[db] conectada con exito')
}


module.exports = connect

version: '3.7'
services:
  mongodb_container:
    image: mongo:latest
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: rootpassword
    ports:
      - 27017:27017
    volumes:
      - mongodb_data_container:/data/db

volumes:
  mongodb_data_container:

'use strict'
const { config } = require('dotenv');
// Recordar instalar MongoDB
// npm i mongodb
// para poder utilizar MongoClient
const { MongoClient } = require('mongodb');

const {
    DB_URL
} = process.env

let connection;

async function connectDB(){
    if(connection){
        return connection;
    }        

    connection = new Promise(async(resolve,reject) => {
        
        try {
            let dbConnection;
            let courses;

            // Creo un new MongoClient
            const client = new MongoClient(`${DB_URL}`);
            // Conecto el client al server
            await client.connect();
            // Establesco la conexión a la base de datos
            dbConnection = await client.db("node_graphql_course_db");
	    // Resuelvo con la dbConnection
            resolve(dbConnection);
        } catch (error) {
            reject(error);
        }
    });

   // Regreso la Promise que emplearé para conectar mi DB
    return connection;
}

module.exports = connectDB;

Configuración de base de datos

Introducción

Introducción al curso y prerequisitos del curso

¿Qué es GraphQL?

Conceptos básicos

Schema y types

Queries y Resolvers

Sirviendo el API en la web

Custom Types

Argumentos

Configuración de base de datos

Integrando una base de datos

Mutations e Inputs

Repaso - Creando el tipo Estudiante

Nested Types

Resolver de tipos

Errores

Conceptos avanzados

Alias y fragments

Variables

Enums

Interfaces - Tipo Monitor

Directivas

Unions

Consumiendo el API

Preparando API para producción

HTTP requests

Clientes de GraphQL

Consumiendo el API desde un frontend simple

Cierre del curso