En este ejercicio, continuaremos con el ejercicio anterior donde
desarrollamos la interacción entre la aplicación de nodo y el servidor MongoDB.
En este ejercicio, voy a encapsular algunas de
las operaciones de base de datos en un módulo de nodo propio,
un módulo de nodo basado en archivos,
y luego hacer uso de él dentro de mi aplicación de nodo para interactuar con el servidor.
Al mismo tiempo, realizaremos varias operaciones en
el servidor para demostrar que podremos
interactuar con el servidor utilizando nuestra aplicación de nodo y el controlador de nodo MongoDB.
Para empezar, vayamos a nuestro proyecto
y luego creamos un nuevo archivo llamado operations.js.
Este archivo encapsulará todas esas operaciones de base de datos,
las cuatro operaciones que voy a realizar insertar,
encontrar, eliminar y actualizar un documento en mi base de datos.
Ahora, esto se organizará como un módulo de nodo basado en archivos,
que luego lo usaré en mi aplicación de nodo para acceder al servidor.
Entonces, para comenzar,
permítanme primero requerir assert,
en este módulo de nodo,
y dado que esto sucede a ser un módulo de nodo,
estaremos exportando varios métodos desde el módulo de nodo.
El primer método sería insertar documento obviamente como cabría esperar,
y esto tomará cuatro parámetros DB,
el MongoDB, conexión de base de datos dentro de mi aplicación de nodo,
que obtendré dentro de la aplicación de nodo.
Entonces, el segundo es el documento que quiero insertar.
El tercer parámetro es la colección en la que quiero insertar el documento.
La última es una función de devolución de llamada,
que será llamada de vuelta una vez que se complete esa operación.
Luego vamos a cerrar la función aquí,
y esto esencialmente encapsula el método de inserción de documento aquí.
Entonces, esta es una función que es exportada por este módulo de nodo aquí.
Ahora, también voy a incorporar algunos métodos más aquí.
El segundo sería encontrar documentos.
No sólo uno, sino varios documentos.
Esto me gustaría buscar en la colección y encontrar todos los documentos que están en la colección.
Entonces, es por eso que solo tomo la base de datos
y la colección como los dos parámetros junto con la devolución de llamada.
La tercera función que voy a implementar una exportación desde aquí es el removedocument.
Esto admite la operación de eliminación,
por lo que el nombre del documento tomará la base de datos, el documento,
la colección y la devolución de llamada como los cuatro parámetros,
y llamaremos a la devolución de llamada cuando se complete la operación.
El último, por supuesto, es actualizar el documento.
Ahora, por supuesto, no necesariamente tienes que hacerlo de esta manera.
Simplemente sentí que esta sería otra forma de ilustrar cómo puedes
encapsular esas funciones en su propio módulo de nodo.
Esto es solo reorganizar el código de una manera que es más fácil de usar.
Entonces, para las exportaciones,
para el documento de actualización toma el DB,
alguna forma de identificar el documento como un segundo parámetro.
El tercer parámetro es la actualización,
y el cuarto parámetro es la colección en la que
existe este documento y la devolución de llamada.
Por lo tanto, cuatro funciones para ser exportadas por el archivo operations.js.
Ahora, dentro de estas funciones,
vamos a implementar una por una.
En el documento de inserción,
lo primero que voy a hacer es decir
colección const y dirá colección DB,
y el parámetro es la colección.
Por lo tanto, vamos a buscar la colección allí.
Ahora, esto tiene que ser realizado en los cuatro métodos.
Entonces, voy a ir y pegar este código en los cuatro métodos aquí,
porque esa es una función que necesito en todos ellos.
Entonces, una vez que me apoye de la colección,
entonces como recuerdas del ejercicio anterior,
puedo realizar operaciones en la colección.
Entonces, diré colección, insertar,
y esto toma como primer parámetro el documento que se insertará,
y el segundo parámetro es la devolución de llamada con el error y ese resultado.
Entonces, ahora cuando este documento
se inserta llamando al método de inserción en la colección de base de datos,
el método de inserción permítanme recordarles,
es compatible con el controlador MongoDB.
Entonces, ese es el método que estamos usando aquí,
o esa es la función que estamos usando aquí.
Ahora, lo primero que voy a comprobar para esto, err assertequal, nulo.
Por lo tanto, quiero asegurarme de que no tengo un error.
Así que quiero asegurarme de que el error sea nulo.
Si no es nulo,
esto imprimirá la información y luego saldrá de la aplicación.
En este momento, siento que esto está bien para manejarlo que más adelante,
veremos cómo podemos tener una forma global de manejar todos los errores cuando
implementemos en la siguiente lección otra forma de acceder a la base de datos MongoDB.
Ahora, después de hacer esto,
voy a implementar,
voy a simplemente registrar esta información.
Así que voy a decir, registro de la consola e insertarlo.
Por lo tanto, esta información se imprimirá en la pantalla aquí, insertada.
Ahora de nuevo, recuerde los puntos y coma y todo lo que
es importante no los olvide cuando esté escribiendo su código.
Entonces, diré resultado insertado.
Este objeto de resultado que se devuelve,
tendrá en él una propiedad llamada propiedad result,
y esta propiedad contendrá un valor.
Esta propiedad de resultado es también un objeto JavaScript,
y esto contendrá una propiedad n que nos indica cuántos documentos se han insertado.
Así que esa es la información que voy a imprimir aquí,
y luego iremos a la siguiente línea y
decimos «documentos en la colección».
Ahora, esta es solo una forma de informar al usuario que esta operación se llevó a cabo correctamente,
y luego pasarán ese resultado a nuestra función de llamada.
Por lo tanto, llamaremos a la devolución de llamada y luego el resultado será el parámetro de la devolución de llamada.
Por lo tanto, cuando implementemos el uso de esta función en nuestro archivo index.js,
vamos a proporcionar la devolución de llamada allí que
recibirá el resultado como el parámetro entrante.
Por lo tanto, esto es para el «InsertDocument».
Ahora, para el «FindDocument
», lo que voy a hacer es decir,
«coll.find» y voy a encontrar todos los documentos.
Entonces, es por eso que daré un objeto JavaScript vacío aquí,
que coincidirá con todos los documentos de la colección y luego diré,
«ToArray» y esto tomará como parámetro una función de devolución de llamada,
y dentro de esta función de devolución de llamada, por supuesto,
afirmaré que esto no es nulo,
y luego diremos, «documentos de devolución de llamada».
Simplemente pasaremos de nuevo los documentos recuperados a la función de llamada.
Ahora, para el «RemoveDocument», voy a decir, «colección DeleteOne».
Por lo tanto, trataré de encontrar el primer documento que
coincida con lo que hemos especificado y luego eliminarlo.
Y luego esto tomará, de nuevo,
una función de devolución de llamada como segundo parámetro,
y dentro de esta función de devolución de llamada,
lo primero que verifico es asegurarme de que el error no sea nulo.
Y luego, después de eso, diremos,
«registro de la consola eliminó el documento con coma».
Usamos la coma aquí porque este es un objeto JavaScript por lo que,
si especifica el registro de la consola como este,
el documento se imprimirá y luego pasaremos
ese resultado a través de la función de devolución de llamada.
Y luego, finalmente, para la actualización vamos a Coll.UpdateOne.
Este es un método que admite el controlador MongoDB.
Por lo tanto, voy a decir, «Update.One document,
" y el segundo parámetro es donde
vamos a pasar en los campos que necesitan ser actualizados.
Y la forma en que se hace,
diremos, «actualización de colon conjunto de dólares».
Por lo tanto, esto tomará la información de actualización que
estoy enviando y luego la pasará a Update.one.
El primero es el documento que debe actualizarse.
El segundo es qué campos del documento deben actualizarse aquí.
Y el tercer parámetro es nulo,
y ese último parámetro es una función de devolución de llamada,
que obviamente nos dará el resultado de la operación.
Entonces, lo primero que voy a verificar para asegurarme de que el error no sea nulo.
Luego, haré un «registro de consola actualizado el documento con».
Ahora, de nuevo, los registros de la consola son puramente para nosotros para
garantizar que el código está haciendo lo que está haciendo.
No ayuda de ninguna manera.
Esto es sólo para nuestra propia información.
En un servidor de producción,
tal vez no tendría estos registros de consola.
Puedes desactivarlos. Así que, eso es todo.
Así que cuatro métodos que se soportan en este módulo de nodo basado en archivos en particular insertar,
encontrar, eliminar y actualizar.
Entonces, ahora que hemos implementado este módulo de nodo basado en archivos,
vamos al archivo index.js,
y luego para hacer uso de ese módulo de nodo basado en archivos,
necesito requerir esto aquí.
Así que, voy a decir, «Const dboper requiere».
Dado que este es un módulo de nodo basado en archivos, obtiene la ruta completa al módulo de nodo,
y que en este caso sucede que lo es. /operations
porque está en la misma carpeta que mi archivo index.js.
Ahora, una vez que hayamos hecho esto,
entonces justo aquí, esta función,
este código que estábamos haciendo para acceder a la base de datos ahora insertar,
vamos a usar el dboper que acabamos de implementar para acceder a esa base de datos.
Entonces, diremos, «dboper insert document
», y este «insert document» toma el db como el primer parámetro.
El db aquí, es este db que entró cuando llamamos a MongoClient connect.
Para que se pase db, de modo que de esa manera,
mi módulo de nodo de operaciones sabe dónde acceder a la base de datos.
Entonces el segundo parámetro es el,
por lo que si miras el «documento de inserción» verás
que el segundo parámetro es el documento que se va a insertar.
Así que, voy a decir, «nombre. «
Solo voy a construir un objeto JSON o un objeto JavaScript aquí,
que se asignará automáticamente al objeto adyacente cuando se inserte.
Y el tercer parámetro, como puede ver,
«colección de documentos db y devolución de llamada.»
Así que el tercer parámetro es la colección y la colección es
la colección de platos y el final es la devolución de llamada.
La llamada de nuevo a medida que recuerde recibe el resultado.
Si mira hacia atrás en el bebé implementó el documento de inserción,
la devolución de llamada recibió el resultado como parámetro.
Entonces, dentro de esta devolución de llamada, manejaremos ese valor de resultado aquí.
Entonces, cuando llegue el valor del resultado, haremos un console.log.
Vamos a decir insertar
barra invertida del documento N y vamos a decir resultados OPS.
El OPS le indica el número de operaciones de inserción que se llevaron a cabo.
Entonces, este es otro objeto que va a estar en el
objeto JavaScript resultado que se pasa
de nuevo como parámetro y así que solo voy a imprimir ese valor.
Así que eso nos dará alguna información sobre lo que ha sucedido.
Ahora, una vez que esto se complete,
dentro de esta función de devolución de llamada voy a llamar a la siguiente operación de base de datos.
Así que voy a decir dboper y luego encontrar los documentos.
Luego diré dbservers y el tercer parámetro es docs,
que es la función de devolución de llamada.
Cuando reciba los documentos, voy a hacer un
console.log diciendo que los documentos encontrados,
y simplemente bloquearemos los documentos en la pantalla.
Por lo tanto, esto imprimirá los documentos encontrados.
Tenga en cuenta que esta llamada está dentro de
la función de devolución de llamada que se aplica para la llamada a función anterior,
por lo que es algo que quiero que note específicamente.
Ahora, de nuevo dentro de esta llamada de función necesitan hacerlo de esta manera porque hasta que
se llame a esta devolución de llamada no podemos hacer la siguiente operación.
Entonces, en la próxima operación voy a actualizar el documento que acabo de insertar.
Así que diré que actualice el documento y diré Actualizar Document DB,
y luego el siguiente parámetro es el documento
y no necesito especificar todo el documento, solo puedo especificar un campo y
luego encontrará el documento que coincida con este campo en particular.
Lo que voy a hacer es que el siguiente parámetro es la actualización que necesita ser suministrada.
Entonces, la actualización es qué campo quiero actualizar,
así que voy a actualizar
el campo de descripción diciendo Prueba actualizada,
y luego la cuarta es la colección que es Platos,
y la última es la función de devolución de llamada que obtiene
los documentos como el valor de retorno o
más bien resultado de la operación de actualización que acabamos de llevar a cabo.
Luego, dentro de esta función de devolución de llamada,
voy a volver a hacer un console.log diciendo
barra invertida del documento actualizado N. El documento actualizado se pasará de
nuevo en result.result en
esta propiedad del objeto resultado que se pasa el seguimiento.
Nuevamente observe cómo las llamadas se anidan
dentro de las funciones de devolución de llamada aquí.
Quiero que note esta estructura del código
específicamente porque eso es a lo que voy a volver en el próximo ejercicio.
Ahora, después de hacer eso,
voy a encontrar los documentos,
así que déjame copiar eso y luego voy a usar el mismo código aquí.
Así que voy a decir, encontrar documentos.
Dentro de aquí voy a decir de nuevo, encontrado documento actualizado.
Entonces, finalmente, cuando termine con esto,
simplemente llamaré a db drop collection.
Así que voy a eliminar esta colección de platos para que
limpie mi base de datos para que no tenga
nada más porque para el próximo ejercicio quiero limpiar
la base de datos y luego comenzar con una base de datos más limpia.
Por lo tanto, voy a limpiar
la colección de platos y esto daría como resultado una devolución de llamada.
Así que dentro de aquí voy a hacer un console.log diciendo,
colección abandonada, y luego simplemente imprimiré el resultado que entró.
Luego, finalmente, cierre la base de datos.
Tenga en cuenta que la estructura del código, el
documento de inserción de DB y dentro de la función de devolución de llamada voy a llamar a
la siguiente función y dentro de
la devolución de llamada apagado que voy a llamar a
la siguiente función y dentro de la siguiente función de devolución de llamada y así sucesivamente.
Por lo tanto, puede ver un conjunto anidado de devoluciones de llamada aquí y
un conjunto anidado estructurado de árbol de devoluciones de llamada aquí.
Eso es algo a lo que quiero que prestes atención.
Vamos a guardar los cambios y vamos a ver esta versión de nuestra aplicación.
Volviendo a la terminal,
déjame ejecutar la aplicación.
Así que déjame escribir inicio de NPM y veremos ese resultado.
Ahora, a partir de este resultado se puede ver que el documento se
inserta en la colección y que es el documento que se ha encontrado.
En el segundo paso,
estamos encontrando el documento por lo que cuando llamamos al documento de búsqueda de base de datos,
este es el documento que se recupera de mi colección.
Luego le pido que actualice el documento con
esto y luego notará que dice documento actualizado y luego
aquí imprime el resultado u OPS y dice que N es igual a
un número modificado como uno y estaba bien.
Luego imprime el documento actualizado,
encontramos el documento actualizado aquí y eso es lo que se imprime aquí,
y observa en particular que la descripción ha sido actualizada.
Luego, finalmente, dejó caer la colección.
Así que vemos cómo se ejecuta esta aplicación y es capaz de hacer uso
del módulo de nodo que implementamos y luego realizamos varias operaciones de base de datos.
Con esto completamos este ejercicio.
En este ejercicio le he demostrado cómo interactuaría con
su servidor MongoDB desde su aplicación de nodo.
Hemos implementado nuestro propio módulo de nodo aquí y luego lo usamos
dentro de nuestra aplicación de nodo encapsulando
algunas de las operaciones de base de datos en ese módulo de nodo.
Este es un buen momento para que hagas una confirmación de Git con
el nodo de mensaje MongoDB ejemplo parte dos.