Como hemos entendido en la conferencia anterior en esta lección,
nuestro objetivo en esta lección es
integrar el servidor REST API que ya hemos desarrollado,
junto con el acceso a la base de datos MongoDB.
Por lo tanto, comenzaremos con el servidor REST API
que construimos en la primera lección de este módulo,
y luego después de haber aprendido cómo interactuar desde
nuestra aplicación de nodo al servidor MongoDB usando Mongoose,
vamos a desarrollar nuestro servidor REST API más para integrar
todo el entre la solicitud del cliente que entra en el servidor,
hasta la operación de base de datos correspondiente a realizar,
y luego construir y enviar de vuelta la respuesta a ese cliente desde nuestro sitio de servidor.
Para empezar, por supuesto, primero,
vaya a la carpeta del servidor de confusión que ya hemos creado en
el primer ejercicio de este módulo en la lección de API REST,
y luego, en la carpeta de confusión,
ya hemos construido el servidor de API REST.
Ahora, lo que estaríamos haciendo es tomar prestados
los modelos que desarrollamos en el ejercicio anterior,
el archivo dishes.js que desarrollamos en el ejercicio anterior,
copiado en el proyecto de servidor de confusión,
y también instalar Bluebird Mangoose,
y otro módulo llamado como Mangoose moneda, a nuestro proyecto.
Entonces, yendo a nuestra carpeta JS nodo,
primero entramos en la carpeta del nodo Mongoose,
y vemos que en la subcarpeta de modelos de la carpeta Mongoose,
tenemos el archivo dishes.js.
Solo voy a copiar la carpeta de modelos,
y luego ir a la carpeta del servidor de confusión,
y luego simplemente perforar la carpeta de modelos allí.
Entonces, una vez que lo hacemos,
entonces el archivo dishes.js que contiene el esquema y el modelo para el documento de platos,
se integran en nuestro servidor REST API.
Por supuesto, para hacer uso de eso,
necesitamos instalar el módulo de nodo de mangosta,
y un nuevo módulo de nodo llamado como moneda de mangosta en nuestro proyecto.
Por lo tanto, yendo al terminal en el proyecto de servidor de confusión,
asegúrese de que su terminal o la ventana de comandos estén
en el proyecto de servidor de confusión donde desarrolle la API REST anteriormente,
y en este proyecto, instalemos.
Por lo tanto, vamos a hacer npm instalar Mangosta,
y luego, un nuevo módulo de nodo llamado como Mongoose currency.
El módulo de nodo de moneda de mangosta,
y visto en otro tipo de esquema a nuestra aplicación de mangosta,
por lo que la mangosta en sí,
ciertamente ya tiene tipos de esquema incorporados.
Hemos visto el uso del número,
la cadena y el booleano, y la matriz.
Ahora, la moneda de Mangosta se suma en apoyo de la moneda.
Ahora, ¿por qué necesitaríamos este apoyo monetario?
Así que el módulo Mongoose añade un nuevo tipo llamado como el tipo de moneda,
que nos permite almacenar un valor de moneda.
Dado que nuestro plato va a contener un precio,
es por eso que voy a usar el módulo de moneda de mangosta aquí.
Ahora, el ejercicio aquí,
vamos a ilustrar el uso del módulo de moneda de mangosta,
se puede leer más detalles sobre el módulo de nodo de moneda de mangosta también,
en la documentación de que un enlace a la que se proporciona en los recursos adicionales.
Por lo tanto, ahora que hemos instalado estos módulos de nodo,
Mongoose y Mongoose,
vamos a nuestra aplicación y configurarlo para comunicarse con el servidor MongoDB.
Ahora, asegúrese de que su servidor MongoDB está en funcionamiento.
Entonces, aquí, ves que
mi servidor MongoDB se está ejecutando en otra pestaña de terminal en mi computadora.
Si lo está ejecutando en un equipo con Windows,
asegúrese de que se está ejecutando en otro comando Window de su equipo con Windows.
Ir a nuestra aplicación en el editor,
primero comenzaremos con el archivo app.js.
Ahora, en el archivo app.js,
aquí es donde construimos nuestra aplicación expresa anteriormente.
Pero ahora, esta negación de succión extra no está conectada al servidor back-end MongoDB.
Vamos a hacer uso del módulo Mangoose,
para establecer la conexión con el servidor.
Así que, al entrar aquí,
voy a agregar el módulo requiere el mangosta aquí.
Entonces, diremos, «Const Mangosta requiere Mangosta».
Y luego también, ya que hemos copiado sobre la carpeta de modelos,
que contiene el archivo de platos,
que declara el esquema de platos y el modelo.
Así que, déjame importar los platos.
Por lo tanto, vamos a decir, «requiere.Modelos slash platos.»
Entonces, una vez que hayamos completado eso, ahora, por supuesto,
tenemos que establecer la conexión con el servidor.
Por lo tanto, configure la
URL mongodb// localhost7017/confusion, al
igual que hicimos con el ejercicio Mangosta,
y luego diremos,
«Const connect, Mongo connect URL».
Por lo tanto, este es exactamente el mismo código que usamos en el ejercicio anterior.
Entonces, establezcamos la conexión.
Por lo tanto, diremos, «conectar» y luego diremos,
«DB hágalo registro de consola».
Decir: «Conectado correctamente al servidor».
Y también manejaremos el error aquí.
Simplemente haremos un registro de consola del error aquí, eso es todo.
Eso establecerá la conexión al servidor desde nuestro archivo app.js.
Entonces, una vez que hayamos establecido la conexión con el servidor,
entonces, abramos el archivo dishes.js de nuestros modelos.
Ahora, en el archivo dishes.js,
para hacer uso
del módulo de nodo que acabamos de instalar.
Por lo tanto, diremos, «Requerir moneda de mangosta», y digamos,
«Cargar el tipo y la mangosta».
Entonces, lo que esto hará es cargar este nuevo tipo de moneda en Mangosta.
A partir de entonces, podemos decir const,
moneda tipos de mangosta moneda.
Eso es todo. Entonces, este nuevo tipo,
el tipo de moneda se agrega a Mangosta y eso agregará un nuevo tipo llamado
moneda y luego voy a declarar
esta moneda constante como la moneda de los tipos de mangosta.
Para que pueda hacer uso de esto al definir el esquema en mi aplicación.
Ahora, en este caso,
el esquema común seguirá siendo exactamente el mismo que antes, pero
el esquema de plato como recuerda del archivo db.json.
Cuando miras la estructura de un documento de plato,
ves que el documento de plato contiene nombre e imagen que como ves aquí es una cadena,
una categoría, una etiqueta,
un precio, que es un tipo de cadena aquí.
Pero vamos a declarar esto como un tipo de moneda,
una característica que como usted espera es una variable booleana,
y una descripción que es una cadena y luego comentarios
que no es más que una matriz de tipo de comentarios.
Ahora, entonces lo que haremos ahora es extender el esquema de plato para
admitir todas estas diversas propiedades o varios campos en mi documento json.
Así que ya tenemos el nombre.
Así que ya tenemos la descripción en su lugar.
Así que tenemos que añadir en los próximos pocos allí ya tenemos los comentarios,
la matriz de comentarios del tipo de esquema de comentario allí.
Así que vamos a añadir en los próximos.
Entonces, el siguiente que agregaremos es el tipo de imagen,
que sería de
la cadena de tipo y
diremos que es necesario verdadero.
Entonces esto agrega el tipo de imagen.
El siguiente que agregaré es categoría,
que también es el tipo de cadena.
El siguiente es la etiqueta,
que también es este tipo de cadena.
Dado que todos estos son del mismo tipo y requeridos,
solo los estoy copiando aquí.
Luego, para la etiqueta,
diría que esto no es necesario, pero
en su lugar también puedo especificar un valor predeterminado si quiero.
Entonces puedo especificar un valor predeterminado como ese.
El valor predeterminado es una cadena vacía.
Por lo tanto, si no especifico requerido, simplemente puedo especificar un valor predeterminado aquí.
Ahora, además, el siguiente campo que voy a introducir es el campo del precio.
El campo de precio declararé el tipo como moneda.
Recordemos que habíamos declarado el tipo de moneda anteriormente
aquí al requerir primero
el módulo Mongoose y luego declarar el tipo de moneda.
Entonces, así es como usarías el tipo de moneda en nuestra aplicación.
Entonces diremos que la divisa del tipo de precio
y requerida es verdadera y luego también puedo especificar el valor mínimo que sería cero.
Luego, el siguiente campo es
el campo destacado que sería del tipo booleano,
y el valor predeterminado será falso.
Por lo tanto, si a mi documento le falta eso,
entonces el valor predeterminado se agregará al documento aquí.
Así que tenga en cuenta que ahora he ampliado
el esquema de plato añadiendo en el tipo de imagen, la categoría,
la etiqueta, el precio y la característica para que coincida con
la estructura del ejemplo de documento de plato que acabo de mostrar antes.
Así que ahora, mi esquema de platos está listo para ser utilizado.
Entonces, ahora comencemos a trabajar en mi enrutador.
Entonces, ¿dónde está el enrutador?
Recuerde que el enrutador que admite los extremos de la API REST para los platos de barra diagonal, el
punto final de la API REST y los platos de barra
diagonal, el punto final de ID de plato de barra se encuentra en el enrutador de plato.
Por lo tanto, iremos al router.jsfile de plato y luego extenderemos el archivo router.js plato.
Entonces, en el enrutador de platos junto con Express y BodyParser,
ahora voy a incluir Mangoose.
Así que vamos a decir requerir mangosta y
luego vamos a requerir platos modelo.
¿ Dónde está el modelo de platos?
Está dentro. /modelos/platos.
Así que está ahí dentro.
Así que observe que estamos en la carpeta del enrutador,
por lo que debe subir un nivel y luego ir a
la carpeta del modelo y luego el archivo dishes.js está allí.
Así que eso es lo que estamos importando aquí.
Así que ahora, puedo actualizar mi router de platos para poder interactuar
con el servidor MongoDB usando
Mongoose y ya hemos importado el modelo de platos en mi router de platos.
Por lo tanto, es hora de ir y actualizar todos los métodos aquí.
Así que para el enrutador de platos,
la barra que significa que el extremo de los platos de corte.
Voy a eliminar todo esto de aquí, en su lugar,
voy a declarar explícitamente todos los diversos puntos finales.
Para publicar y eliminar, manejaré cada uno de ellos de forma independiente.
Entonces, en el método get,
voy a cortar eso y luego en el método get, ¿qué necesito hacer?
Recordemos que habíamos definido el método de Mangosta que nos permite encontrar todos los platos.
Por lo tanto, cuando realiza una operación get en el punto final de platos de barra,
espera que todos los platos se devuelvan
al cliente en respuesta a la solicitud get.
Entonces, voy a ir a los platos y luego realizar la operación de búsqueda.
Así que ahora ves que desde mi servidor Express,
estoy accediendo a mi MongoDB.
Entonces, haré un hallazgo y en el hallazgo ahora voy a manejar la solicitud.
Así que puedo decir que los platos encuentran,
ya que eso va a devolver una promesa,
entonces puedo manejar eso aquí dentro.
Por lo tanto, diré plato y así que si la promesa se resuelve correctamente,
lo obtendré en el entonces y así diré plato y luego manejaremos el
código de estado res es 200 y luego diremos
res tipo de contenido de encabezado establecido res.
Dado que vamos a devolver el valor como un json,
lo estableceremos en la aplicación json.
Vale, esto devolverá una variedad de platos.
Así que simplemente puedo decir platos y luego diremos res.json.
Entonces, res.json tomará como entrada en la cadena json
y luego la enviará de vuelta a mi cliente.
Entonces, cuando llame a res.json y proporcione el valor y luego simplemente
tomará el parámetro que da aquí y luego lo enviará como una respuesta json.
Pondrá estos platos en el cuerpo
del mensaje de respuesta y luego lo enviará de vuelta al servidor.
Ahora, podemos manejar el error
aquí diciendo el siguiente error.
También podemos hacer un error de captura solo por el bien de completo.
Sólo voy a poner ambos en su lugar aquí,
para que ambos sean manejados como tales.
Entonces, si se devuelve un error,
eso simplemente pasará el error al
controlador de errores general para mi aplicación
y el dejar que se preocupe sobre cómo manejar el error.
Así que vamos a enviarlo a eso.
Entonces verá cómo estoy usando la operación de búsqueda y luego realizando la solicitud aquí.
Ahora, para el post,
como ya habrías esperado,
voy a hacer plates.create
porque vamos a crear un nuevo plato aquí.
Por lo tanto, recuerde que ya se ha visto que los platos crean el
uso del método antes y recuerde que el analizador corporal
ya habría analizado lo que está en el cuerpo del mensaje y lo ha cargado
en la propiedad body de la solicitud.
Por lo tanto, solo tomaré el cuerpo de la solicitud y luego lo analizaré como parámetro para mi
método dishes.create y manejaré el valor de retorno.
Entonces, diremos entonces y esto devolvería
un plato y lo manejaremos aquí.
Así que diremos si los platos regresan correctamente y si los platos se publican correctamente, dirán res.
Bien, hagamos un console.log para nuestro propio uso.
En el lado del servidor haremos un plato console.log diciendo «Dish Created» aquí.
Vamos a registrar ese plato en la consola y luego diremos estos dos códigos de estado de descanso.
Vamos a copiar ese código y luego pegarlo allí y en este caso,
vamos a devolver el plato aquí.
El plato que ha entrado como un parámetro aquí y luego deja que
el cliente lidiar con ese valor en el lado del cliente,
lo que sea que se devuelva en el plato.
Ahora, también agregarán en
esto aquí y luego la captura.
Así que así es como manejamos el post.
Para el PUT, porque PUT no está permitido,
así que vamos a dejarlo como tal.
Para DELETE, vamos a eliminar todos los platos.
Así que vamos a decir, «platos.Quitar».
Esta es esencialmente una operación peligrosa.
Así que usted está eliminando todos los platos
del servidor y así vamos a decir,
«platos.Retire entonces» y el «entonces» obtendrá algo de respuesta.
Así que simplemente diremos, «resp here» y la forma en
que manejaríamos esa respuesta es simplemente tomar ese valor y luego devolverlo al cliente.
Entonces diremos, «Res.statusCode 200 tipo de contenido json», y
luego simplemente enviaremos la respuesta al cliente y manejaremos el error
como lo hicimos antes.
Esa es la operación DELETE.
Así que ves que ahora estamos haciendo la
operación GET, POST, PUT y DELETE.
Ahora vamos a continuar lo mismo con el punto final /DISHID.
Así que en este caso,
estamos específicamente el motivo de obtener un plato específico.
Vamos a devolver ese valor específico del plato.
Así que en el GET,
lo que hacemos es decir «dishes.FindbyId.
Entonces, el findById es un método que está disponible tanto desde mongo como desde el controlador MongoDB.
Así que diremos,» Req.Params.Dishid.»
Recordemos que ya sabemos que el ID del plato está presente en la propiedad params.
Ya has aprendido sobre esto antes.
Así que diré, «findById (req.params.dishid)» y
luego y el otro.
Así que voy a copiar eso entonces y otra desde
allí y luego bajar al DishRouter y
luego simplemente pegar eso aquí.
Entonces diremos, "Res.statusCode200
aplicación json.res.jsondish y luego el manejo de errores.
Para la POST, obviamente no vamos a manejar la publicación para un endpoint /DISHID.
Así que vamos a dejarlo como tal.
Para PUT, vamos a actualizar
un plato específico que se identifica por su ID de plato.
Así que aquí es donde vamos a utilizar dishes.FindByidandUpdate.
Así que este es el método que vamos a usar,
findByidandUpdate y esto toma como primer parámetro
req.params.dishid y el segundo valor es
el conjunto y la actualización
estará en el cuerpo del mensaje.
Así que voy a recuperar eso
del cuerpo de reconocimiento y luego también de la otra bandera que voy a tener.
Así dirá, «nuevo: verdadero», para que este método FindById devuelva
el plato actualizado como una cadena json en la respuesta.
Así que eso es lo que voy a conseguir aquí y cuando ese valor llegue,
sólo voy a tomar el plato y
luego simplemente devolver el plato al lado del cliente.
Así que diré res.jason (dish) y luego manejaremos el error correspondientemente.
Finalmente para el DELETE.
Para el DELETE de nuevo,
el método correspondiente que vamos a
usar es el método de Mongo llamado FindByIDandRemove.
Así que puedes ver que tenemos este método llamado
FindByIDandRemove y este FindByIDandRemove,
tomará req.Params.Dishid porque ese es el plato que estamos tratando de eliminar.
Luego, cuando esto se elimina,
así que al igual que manejamos esto aquí,
así que solo voy a copiar este código de los plates.Remove.
Es lo mismo que voy a hacer aquí también.
Así que FindByidandRemove y cualquiera que sea la respuesta que obtenga,
lo devolveré a mi cliente.
Con esto hemos actualizado el DishRouter.
Guardemos todos los cambios que hemos hecho
hasta ahora y luego iremos a poner en marcha nuestro servidor y luego veremos qué hace.
Entonces, yendo al terminal o a la ventana de comandos, inicie el servidor.
Entonces diré «inicio npm» y el servidor ahora está en funcionamiento.
Vamos a usar al cartero para comunicarnos con este servidor.
Así que vayamos al cartero y luego realizamos ciertas operaciones.
Así que aquí ves a mi cartero arriba y corriendo aquí.
Así que déjame hacer una operación GET en el localhost: 3000/platos.
Entonces, cuando haces una operación GET como ves,
devolverá una cadena vacía.
Mi base de datos ahora está vacía, así que no tengo nada allí.
Así que solo me van a devolver una cadena vacía.
Vamos a publicar un plato.
Así que cuando publiques un plato,
obviamente en el cuerpo,
estarás adjuntando un plato y el cuerpo se configurará para ser el tipo json de aplicación.
Ahora, para publicar un plato,
ya te he dado el archivo db.json en los recursos del ejercicio.
Así que simplemente abra el archivo db.json y luego copie el primer plato desde
allí y luego lo pegaremos aquí y luego publicaremos ese plato.
Así que, déjame ir al archivo db.jason.
Déjame copiar el primer plato de aquí.
Así que voy a copiar
todo el plato hasta allí y luego voy a publicar este plato.
Esto contiene muchos de los campos que ya tenemos aquí.
Vamos a publicar este plato en el servidor y ver qué sucede.
Así que volvemos con el cartero.
Aquí, en los datos del formulario,
en el cuerpo, déjame pegar el plato en su lugar.
Entonces, tenemos todos los detalles del plato allí.
Vamos a POST este plato al servidor.
Luego, una vez que el plato se publica en el servidor,
ves que el cartero tiene,
déjame simplemente reducir esto,
y luego ves en la parte inferior que este plato en particular ha sido publicado en la base de datos, en la base de datos de
MongoDB por mi servidor.
Por lo tanto, verá que el valor devuelto
aquí muestra cuándo se insertó el plato en ese servidor.
Por lo tanto, tiene CreateDat y UpdateDat agregados allí.
Verá que los campos restantes se almacenan allí.
Tenga en cuenta en particular cómo se almacena allí el valor del precio.
Así es como la divisa almacena el valor del precio.
Por lo tanto, cuando obtenga el valor de retorno,
debe interpretar esto apropiadamente en el lado del cliente lo que eso significa.
Tenga en cuenta también que el ID se ha añadido a mi plato y para cada comentario en sí,
porque cada uno de los comentarios es en sí mismo es un sub-documento.
Tendrá UpdateDat y CreateDat agregados,
y el ID de cada uno de los comentarios también agregado automáticamente por mi base de datos.
Ahí lo tienes. Así que ahora,
este plato se ha añadido a mi base de datos.
Volvamos a realizar la operación GET,
y obviamente en este punto,
el servidor debe devolver ese plato en particular que se ha agregado.
Por lo tanto, devolverá una variedad de platos aquí,
por lo que como se puede ver, devuelve una variedad de platos.
Por supuesto, esta matriz contiene solo un plato
o ese plato en particular ha sido devuelto aquí.
Hasta ahora, tan bien.
Entonces, hagamos un PUT en los platos y veamos qué sucede.
Cuando haces un PUT, obviamente, dice,
«operación PUT no soportada en platos», como esperamos.
Vamos a hacer un DELETE.
Haciendo una operación DELETE,
devuelve esta respuesta diciendo,
«N es igual a uno», vale,
uno significa que ha eliminado un plato.
Vamos ahora de nuevo, realizar una operación GET,
y luego verías que mis platos están vacíos como esperábamos.
Por lo tanto, puede ver que las
operaciones GET, PUT, POST y DELETE funcionan correctamente.
Ahora, permítanme POST
el plato nuevamente al servidor porque quiero tener un plato en el servidor.
Entonces, déjame POST ese plato,
y notarías que el ID ha cambiado ahora.
Entonces, déjame seleccionar ese ID,
y luego haremos un GET con el ID en su lugar.
Cuando haces un GET con el ID en su lugar,
ves que devuelve ese plato específico como lo esperas.
Vayamos a la terminal y veamos qué
se imprime en la terminal o en la ventana de comandos.
Por lo tanto, yendo a la terminal o a su ventana de comandos,
verá que está imprimiendo todas estas cosas en la ventana de comandos.
Entonces, cuando hicimos la primera operación GET,
dice, GET /dishes.
Entonces, esto es de nuevo,
Morgan haciendo este trabajo para usted, está imprimiendo,
rastreando esta información y dice plato creado
y luego esa información particular del plato se ha impreso,
y luego dice POST /platos, GET /platos,
y luego cuando hiciste un PUT devolvió un 403
allí y de nuevo creaste platos y así sucesivamente.
Por lo tanto, ve que su servidor realmente está haciendo todo el trabajo,
y estas cosas se están insertando en su base de datos MongoDB como esperaba.
Ahora, volviendo al Cartero,
hagamos una POST de los platos.
Ahora, esto no es compatible en el lado del servidor,
por lo que su servidor debe decir,
«La operación POST no es compatible con ese extremo particular», como es de esperar.
Hagamos una operación PUT.
Cuando haces una operación PUT,
lo que voy a hacer en la operación PUT es que voy a
reemplazar la etiqueta allí.
Así que, en mi cuerpo del mensaje.
Por lo tanto, recuerde que si miras el archivo DB.json,
la etiqueta para eso sería nueva,
y entonces voy a cambiar esa etiqueta a hot.
Dado que esto necesita estar en Json,
por lo que etiqueta también entre comillas Json label hot,
y luego vamos a hacer un PUT en ese punto final en particular.
La operación PUT se realizó correctamente,
por lo que verá que cuando se realizó la operación PUT,
entonces notará que la etiqueta ahora ha cambiado de nuevo a caliente aquí,
y tenga en cuenta, en particular, el valor
CreateDat y el valor UpdateDat.
Por lo tanto, observe que este registro se creó
en este momento y se actualizó un poco más tarde.
Entonces, la actualización fue realizada por la operación PUT que acabo de
realizar en ese plato en particular.
Vamos a borrar el plato.
Esto está permitido. Por lo tanto, eliminaremos el plato,
y luego el plato se eliminará y se devolverá el valor.
Ahora, si realiza una operación GET en
el extremo de los platos, verá que esto devolverá un vacío.
Por lo tanto, acabas de eliminar el plato de nuestra base de datos.
Lo que voy a hacer es realizar
una operación GET en un plato inexistente y ver qué sucede.
Cuando realizo una operación GET en un plato inexistente,
devuelve null porque ese plato no existe.
Por lo tanto, devuelve un valor nulo que dice que el plato no existe.
Ahora, permítanme realizar una operación GET en un no ObjectID y ver qué sucede.
Regresa como ves.
Déjame previsualizar eso.
Por lo tanto, dice, «La conversión a ObjectID falló para el valor aquí en la ruta».
Por lo tanto, obviamente, este no es
un ObjectID válido, así que solo logré eliminar parte de él,
y luego realizar la operación para que devuelva un error que dice,
por lo que verá que hay 500 errores internos del servidor.
El servidor no pudo manejar esto y luego devolver este valor aquí.
Así que dice: «No,
esto no está permitido».
Entonces, porque eso no es un ObjectID válido.
Por lo tanto, incluso los errores se manejan apropiadamente como se ve aquí.
Entonces, permítanme de nuevo, haga una operación GET en los platos,
y su servidor aún se está ejecutando,
y devolverá un valor vacío aquí.
Por lo tanto, hemos visto cómo modificando
nuestro servidor API REST para poder interactuar con el servidor MongoDB.
Ahora tenemos un servidor API REST completo que es capaz de almacenar,
recuperar, y realizar varias operaciones
en los datos que se almacenan en mi servidor MongoDB.
Con esto, completamos este ejercicio.
Por lo tanto, en este ejercicio,
hemos visto cómo somos capaces de interactuar con nuestro servidor REST API,
y a su vez, con el servidor MongoDB,
y luego estamos aprovechando el servidor MongoDB para almacenar y recuperar datos del servidor.
Puede interactuar desde
nuestra aplicación Express con el servidor MongoDB usando Mongoose.
Este es un buen momento para que realice una confirmación de GIT con el mensaje
«Express REST API with Mangoose Part One».