DEV Community: JessicaMeleroDev

Curiosidades del tipo de datos de MongoDB

JessicaMeleroDev — Wed, 10 Feb 2021 17:27:06 +0000

Hoy voy ha hablar sobre los distintos tipos de datos que acepta MongoDB.

Sabemos que existen los datos tipo Null, Number, String, Boolean y Array entre otros. Bien, pues MongoDB acepta todos estos y también documentos embebidos, expresiones regulares, datos tipo fecha, tipo ObjectID, datos binarios e incluso código Javascript!!

Sí, puedes almacenar en un dato una función escrita en Javascript ya que, al fin y al cabo la terminal de mongo es un intérprete de Javascript.

{"algun_dato": function(){...}}

Me parece interesante el tipo ObjectID. {"_id":ObjectId("601d90b9414ff5d41b3e0eb3")}
Podemos ver que es un conjunto de 24 números y letras pero, ¿qué son estos números y letras?.
Estos números tienen su sentido aunque no lo parezca. Los 18 primeros hacen referencia al timestamp, es decir, el tiempo en milisegundos correspondientes al momento de creación del documento. Y los 6 últimos es un contador que se va autoincrementando por cada nueva inserción.

También es curioso el tipo de dato documento embebido. Esto significa que dentro del documento hay otro documento.

{
  "nombre":"Enki",
  "edad": 6,
  "direccion": {
     "calle": "Calle Mayor, 5",
     "poblacion": "Alicante",
     "provincia": "Alicante",
     "pais": "Spain"
  }
}

En este caso la dirección es el segundo documento. Dependiendo de la magnitud del documento principal y de la lógica empleada, podría ser conveniente separarlo en otro documento y referenciarlo.

💡 ¿Qué hace mongo por detrás?

Si quieres saber qué hace por detrás una función de mongo, simplemente ejecútala pero sin paréntesis.

> db.mascotas.find
function (query, fields, limit, skip, batchSize, options) {
    var cursor = new DBQuery(this._mongo,
                             this._db,
                             this,
                             this._fullName,
                             this._massageObject(query),
                             fields,
                             limit,
                             skip,
                             batchSize,
                             options || this.getQueryOptions());

    {
        const session = this.getDB().getSession();

        const readPreference = session._serverSession.client.getReadPreference(session);
        if (readPreference !== null) {
            cursor.readPref(readPreference.mode, readPreference.tags);
        }

        const readConcern = session._serverSession.client.getReadConcern(session);
        if (readConcern !== null) {
            cursor.readConcern(readConcern.level);
        }
    }

    return cursor;
}

Así podrás ver cómo es la función que actúa por detrás cuando realizas este comando 😉

Como he dicho antes, la terminal de mongo es un intérprete de Javascript, ¿qué significa esto? Significa que podemos ejecutar código Javascript en su terminal e incluso scripts.
Realmente, cuando ejecutamos estos helpers de mongo

> use db
> show dbs
> show tables

por detrás se está ejecutando respectivamente

> db.getSisterDB('db')
> db.getMongo().getDBs()
> db.getCollectionNames()

Os animo a que probéis este último apartado y así entender un poco más cómo funciona MongoDB.

Espero que os haya servido y os haya parecido interesante. Cualquier duda o aportación, ya sabéis, dejar un comentario abajo 👇

Consultas básicas en MongoDB por terminal

JessicaMeleroDev — Fri, 05 Feb 2021 18:59:00 +0000

Si eres de las personas que no les gusta usar los distintos programas que hay para el manejo de las base de datos o simplemente quieres saber cómo manejarte por consola, aquí puedes ver algunos ejemplos de consultas básicas.

Para entrar en la terminal de MongoDB ejecuta en tu terminal mongo o mongod.

Si aparece algo similar a lo siguiente, entonces todo está correcto.

MongoDB shell version v4.0.11
connecting to: tu_mongo_uri
Implicit session: session { "id" : UUID("tu_mongo_id") }
MongoDB server version: 4.0.11

Una vez dentro, puedes ejecutar el siguiente comando usando la palabra show para ver todas tus bases de datos:

> show databases

o puedes abreviarlo

> show dbs

Este comando mostrará un listado de bases de datos con los GB que ocupan.

Para poder ejecutar cualquier consulta tienes que seleccionar la base de datos sobre la que quieres realizar dicha consulta. Con la palabra use ejecuta:

> use nombre_db

Este comando no muestra nada, pero ya le estás diciendo a mongo que quieres usar esa base de datos. Al igual que el comando > show dbs que muestra las bases de datos, existe uno parecido para mostrar todas las tablas:

> show tables

o también

> show collections

Ahora hay que seleccionar la tabla o colección para poder realizar operaciones sobre ella. Para ello se usa la misma sentencia que para seleccionar una base de datos pero poniendo el nombre de nuestra tabla.

Una vez seleccionada ya podemos hacer consultas sobre ella.

Operaciones CRUD 💻

Find (👀)

La primera consulta es la más sencilla, recoger todos los documentos de la tabla o colección. Ejecutamos lo siguiente:

> db.mascotas.find()

Si queremos encontrar un documento específico filtrando por algún campo, cambiaremos find() por findOne() y dentro del paréntesis se pone el filtro que queremos. Como por ejemplo:

> db.mascotas.findOne({nombre: "Enki"})

Create ➕

Para crear un nuevo registro en nuestra base de datos usamos el método save() y dentro de sus paréntesis ponemos los datos coincidiendo con el modelo de datos. Ejemplo:

> db.mascotas.save({"nombre":"Duna", "especie":"Felino", "sexo":"Hembra", "edad":1, "propietario":"Jessica Melero"})

Si todo ha ido bien mostrará:

WriteResult({ "nInserted" : 1 })

Update ✏️

Para poder actualizar un documento usaremos el método updateOne() y la palabra $set. En este caso hay que pasarle dos parámetros, el primero es el filtro por el que buscará mongo para encontrar el documento que va a editar. Y el segundo son los parámetros que se van a modificar que puede ser simplemente uno o varios. Dejo un ejemplo de cada caso.

> db.mascotas.updateOne({nombre:"Enki"}, {$set: {edad: 4})

> db.mascotas.updateOne({nombre:"Enki"}, {$set: {edad: 4, propietario: "Jessica"})

☝️Fíjate en la segunda propiedad que vas a actualizar. Asegúrate de que está dentro de los corchetes de $set: {} y no fuera. Puedes poner tantas propiedades como desees actualizar.

Si todo ha ido bien aparecerá:

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

En el caso de que no encuentre el documento aparecerá "matchedCount":0 y "modifiedCount":0.

Delete ❌

Para eliminar un documento de la base de datos usaremos el método deleteOne() y el parámetro que le pasamos es similar a cuando buscamos un documento en concreto. Voy a poner un ejemplo para que se vea mejor:

> db.mascotas.deleteOne({nombre:"Duna"})

Si todo va bien aparecerá algo similar al mensaje de actualizar un documento pero sin "matchedCount":0.

{ "acknowledged" : true, "deletedCount" : 1 }

Este comando para eliminar un documento, pero si quieres eliminar una colección entera entonces tienes que ejecutar el método drop()

> db.mascotas.drop()

Si no hay ningún error aparecerá true, si no puede eliminar la colección devolverá false.

ℹ️ Para salir de la consola escribe > exit

🎯 TIP

Como habrás podido observar, cuando haces un find() o findOne(), la consola te muestra todo sin formato. Existe un método llamado pretty() que se coloca justo después que deja el código en formato json.

Sin formato

> db.mascotas.find()
{ "_id" : ObjectId("id_mongo"), "nombre" : "Enki", "especie" : "conejo", "sexo" : "Macho", "edad" : 5, "propietario" : "Jessica" }
{ "_id" : ObjectId("id_mongo"), "nombre" : "Duna", "especie" : "felino", "sexo" : "Hembra", "edad" : 1, "propietario" : "Maria" }

Con formato

> db.mascotas.find().pretty()
{
    "_id" : ObjectId("id_mongo"),
    "nombre" : "Enki",
    "especie" : "conejo",
    "sexo" : "Macho",
    "edad" : 5,
    "propietario" : "Jessica"
}
{
    "_id" : ObjectId("id_mongo"),
    "nombre" : "Duna",
    "especie" : "felino",
    "sexo" : "Hembra",
    "edad" : 1,
    "propietario" : "Maria"
}

Espero que haya servido de ayuda 😊
Si surge algún error en algunas de estas consultas dejarla en los comentarios y las resolvemos.

Creación de una API sencilla con NodeJs en Español

JessicaMeleroDev — Wed, 03 Feb 2021 19:44:51 +0000

En este post vamos a crear una API bastante sencilla para iniciarse en el mundo de Node y Express conectándola a una base de datos no-relacional en local.

Pre-requisitos 🚀

Necesitas tener instalado:

NodeJS (https://nodejs.org/es/download/)
MongoDB (https://docs.mongodb.com/manual/administration/install-community/)
Tu editor de código favorito, Atom, Visual Studio, etc.
MongoDB Compass (https://www.mongodb.com/try/download/compass)
Postman o similar (https://www.postman.com/downloads/).

Si no tienes alguno, pincha en el enlace y sigue los pasos 😉

El resto de dependencias las instalaremos con el gestor de paquetes de node.

Empezamos... 💻

Lo primero de todo vamos a empezar definiendo lo que es una API. Una API es un conjunto de protocolos por los cuales el front se comunica con la base de datos y obtiene respuesta de sus peticiones. Existen distintos tipos de métodos de comunicación, pero los más usados son GET, POST, PUT y DELETE.

Sabiendo esto, voy a dividir en 5 apartados todos los pasos a seguir para la creación de esta API.

Parte I. Inicialización del proyecto.

Lo primero de todo es crear una carpeta en un directorio y ponerle un nombre. Abrimos la terminal en el directorio de la carpeta y escribimos:

npm init

Tras darle a intro aparecerán una serie de preguntas como las siguientes del cuadro azul:

Puedes ir rellenando cada pregunta o presionar enter con lo que sale por defecto.

Este comando crea un archivo llamado package.json el cual contiene información sobre el proyecto como el nombre, descripción, el autor... y además contendrá todas las dependencias que vayamos instalando.

Los siguientes comandos son para la instalación de dependencias que se van a utilizar en el proyecto.

npm install express express-validator dotenv mongoose --save

npm install nodemon --save-dev

El segundo comando son las dependencias que se usan solo en el entorno de desarrollo.

ℹ️ Dejo los enlaces a la documentación oficial de las librerías instaladas
ExpressJS
express-validator
dotenv

Una vez todo instalado, hay que crear en la raíz del proyecto el archivo del que arrancará el servidor, index.js

Para poder arrancar el proyecto es necesario que se edite el archivo package.json y añadir las siguientes líneas:

 "scripts": {
    "start": "node .",
    "dev": "nodemon .",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

Esto hará que el servidor arranque con Node o con nodemon.

📖 Breve explicación 📖

Voy ha hablar un poco de esta librería, nodemon. Nodemon nos permite ver a través de la consola todas las peticiones que se van haciendo. Además, si estás codificando y guardas el archivo, nodemon automáticamente te recarga el servidor sin que tengas que pararlo y volver a arrancarlo. Esta librería me parece bastante interesante de utilizar a la hora del desarrollo, por eso, como puedes ver está dentro de un apartado llamado "devDependencies" y no en "dependencies".

Seguimos... ☕

Una vez actualizado el package.json, ejecutamos:

npm run dev

Tiene que aparecer algo así:

Hasta aquí sería la primera parte, la inicialización del proyecto y el arranque del servidor. En el siguiente apartado se crea la conexión a la base de datos y se crean las variables de entorno.

Parte II. Conexión a la BD y variables de entorno.

En este apartado vamos a crear un archivo en el que crearemos la conexión a la base de datos. Antes de todo, para poder ver las tablas que se irán creando es necesario tener MongoDB Compass, ya que ahí en donde las podremos ver más fácilmente que por consola.

Creamos en la raíz del proyecto una carpeta llamada config y dentro un archivo db.js como el siguiente:

También crearemos el archivo .env en la raíz del proyecto y añadiremos:

PORT=3000
DB_MONGO="url_mongo"

En el archivo .env, la variable DB_MONGO suele tener la siguiente estructura: "mongodb://localhost:27017/api"
Suele ser localhost si es en local. Después va el nombre de la base de datos.

Una vez creado el archivo .env, hay que editar el archivo index.js e importar la variable PORT y la función conectarDB

Como se puede ver en la imagen, los cuadrados azules representan los cambios que hay que hacer en el archivo.
*El primero, son las importaciones de la función para conectar la base de datos const conectarDB = require('./config/db.js') y el archivo de las variables de entorno require('dotenv').config({path: '.env'})
*El segundo, conectarDB() es la llamada a la función de la conexión a la base de datos.
*Y el tercero, const port = process.env.PORT || 4000 se puede ver que hay un 'or'. Esto significa que si el valor de la variable de entorno está en uso, cogerá por defecto el valor '4000'.

Si todo a ido bien, podremos observar en la terminal lo siguiente:

Ya estamos conectados a nuestra base de datos!!

Parte III. Creación del modelo.

Ya tenemos lo más importante funcionando, ahora hay que crear nuestro modelo de datos. Para ello creamos una carpeta llamada models que es donde se ubicarán todos los modelos. Dentro, creamos un archivo con el nombre de nuestro modelo, en mi caso lo he llamado mascota.js y queda así:

En este archivo se pueden ver las propiedades que va a tener nuestro modelo.

Podemos ver 3 tipos de datos: String, Number y Date. Estos tipos de datos son los más usados junto con Boolean que en este caso no hemos utilizado. También se puede ver en el apartado sexo que hay enum:['Macho', 'Hembra']. El enum hace que solo se permitan los valores que hay entre los [], sino coinciden con esos, salta un error.

El apartado require: true hace que si a la hora de hacer una nueva inserción en la base de datos no está ese campo, saltará un error diciendo que es requerido ese campo.

En cuanto al apartado

date: {
  type: Date,
  default: Date.now
}

se puede poner así dentro de las propiedades o de esta manera que se crean los updatedAt y createdAt:

const MascotaSchema = mongoose.Schema({...},{
  timestamps: true
})

Dejo aquí el enlace a la documentación de MongoDB para poder echar un vistazo a todos los tipos de datos y algunos ejemplos de su uso.

Parte IV. Creación de las rutas.

Ya tenemos nuestro modelo, ahora ha crear las rutas para realizar las peticiones GET, POST, PUT, DELETE.

Primero, creamos una carpeta llamada routes y dentro el archivo mascota.js en mi caso. Es importante que los archivos se nombren en referencia a lo que hacen para así tener una idea más clara de su contenido.

Las primeras lineas son las importaciones

Después ya van las rutas. Vamos a empezar con la ruta de creación de una mascota, en este caso usamos POST.

Como sale en la imagen, hay 3 parámetros. El parámetro 1 es la ruta misma. En este caso solo tiene '/', pero podemos poner lo que queramos como por ejemplo router.post('/crear')
El parámetro 2 utiliza express-validator para comprobar que todos los campos se pasan en la llamada y en caso de faltar alguno salta el mensaje que hay en las segundas comillas 'El nombre es necesario'
check('nombre','El nombre es necesario').not().isEmpty()

Y el parámetro 3 es la función que ejecuta la llamada a la base de datos y devuelve la respuesta del servidor. En el siguiente apartado separaremos este parámetro en un controlador y así evitar que nuestro archivo tenga tantas lineas de código y se vea mas limpio.
ℹ️ Todo código que se repita se puede separar en un archivo y reutilizarlo.

La llamada GET para recoger todos los datos quedaría así:

en este caso solo hay 2 parámetros.

❗No hay que olvidar importar este archivo en el index.js de esta forma:

// Importamos las rutas
app.use('/api/mascotas', require('./routes/mascota'))

❗No olvidar el module.exports = router; al final del archivo.
Una vez creadas estas dos llamadas, hay que comprobar que realmente está funcionando, en mi caso Postman.

POST

RESPUESTA POST

GET + RESPUESTA

Llegado a este punto el código ya funciona!!

Parte V. Creación del controlador.

Este apartado es el mas sencillo de todos. Se trata de separar la función que hay en la llamada y ponerla en otro archivo. Para ello, creamos una carpeta controllers y dentro un archivo mascota.js como este:

He añadido una pequeña funcionalidad dentro de cada función

// Revisar si hay errores
    const errores = validationResult(req);
    if (!errores.isEmpty()) {
        return res.status(400).json({ errores: errores.array() })
    }

Esto es para que compruebe que no existe ningún error antes de hacer la llamada a la base de datos. En caso afirmativo salta el error.

❗ No olvidar quitar la función del archivo de rutas y sustituirlo por router.get('/', mascotaController.recogerMascotas) e importarlo al principio del archivo const mascotaController = require('../controllers/mascota') como muestra la imagen

Como práctica dejo por hacer la llamada de actualizar y de eliminar para que practiques. Más abajo dejo el enlace a mi GitHub para consultar cualquier duda.

Y por fin tenemos nuestra pequeña API!!

🔗 Recursos

GitHub (https://github.com/JessicaMeleroDev/SIMPLE-CRUD-API-NODEJS)

Cualquier duda no dudes en dejarla en los comentarios 😄