Come abbiamo capito dalla lezione precedente di questa lezione, il
nostro obiettivo in questa lezione è quello di
integrare il server API REST che abbiamo già sviluppato,
insieme all'accesso al database MongoDB.
Quindi, inizieremo con il server API REST
che abbiamo costruito nella prima lezione in questo modulo,
e poi dopo aver imparato come interagire dalla
nostra applicazione nodo al server MongoDB utilizzando Mongoose,
stiamo andando a sviluppare il nostro server API REST ulteriormente per integrare
l'intero percorso tra la richiesta del client che entra nel server,
fino alla corrispondente operazione di database da eseguire,
e quindi costruire e inviare la risposta a quel client dal nostro sito server.
Per iniziare, naturalmente, prima,
vai alla cartella del server confusione che abbiamo già creato
nel primo esercizio di questo modulo nella lezione API REST,
e poi, nella cartella confusione,
abbiamo già costruito il server API REST.
Ora, quello che dovremmo fare è prendere in prestito
i modelli che abbiamo sviluppato nell'esercizio precedente,
il file dishes.js che abbiamo sviluppato nell'esercizio precedente,
copiato nel progetto del server di confusione,
e anche installare Bluebird Mongoose,
e un altro modulo chiamato come Mongoose valuta, al nostro progetto.
Quindi, andando alla nostra cartella nodo JS,
prima andiamo nella cartella nodo Mongoose,
e vediamo che nella sottocartella modelli della cartella nodo Mongoose,
abbiamo il file dishes.js.
Ho solo intenzione di copiare la cartella dei modelli,
quindi andare alla cartella del server di confusione,
e quindi semplicemente perforare la cartella dei modelli lì dentro.
Quindi, una volta fatto ciò,
il file dishes.js che contiene lo schema e il modello per il documento piatti,
sono integrati nel nostro server API REST.
Naturalmente, al fine di fare uso di questo,
abbiamo bisogno di installare il modulo nodo Mongoose,
e un nuovo modulo nodo chiamato come Mongoose valuta nel nostro progetto.
Quindi, andando al terminale nel progetto del server di confusione,
assicurati che il tuo terminale o la finestra di comando si
trovi nel progetto del server di confusione in cui sviluppi l'API REST in precedenza
e in questo progetto, installiamo.
Quindi, faremo npm installare Mongoose,
e poi, un nuovo modulo nodo chiamato come valuta Mongoose.
Il modulo nodo valuta Mongoose,
e visto in altri tipi di schema per la nostra applicazione Mongoose,
quindi la stessa Mongoose,
ha certamente già tipi di schema incorporati.
Abbiamo visto l'uso del numero,
la stringa e il booleano, e l'array.
Ora, la moneta Mangusta aggiunge il supporto per la valuta.
Ora, perché dovremmo avere bisogno di questo supporto monetario?
In modo che il modulo di valuta Mongoose aggiunge un nuovo tipo chiamato come il tipo di valuta,
che ci permette di memorizzare un valore di valuta.
Dal momento che il nostro piatto sta per contenere un prezzo,
è per questo che ho intenzione di utilizzare il modulo valuta Mongoose qui.
Ora, l'esercizio qui,
illustreremo l'uso del modulo valuta Mongoose,
è possibile leggere ulteriori dettagli sul modulo nodo valuta Mongoose anche,
nella documentazione di che un link a cui è fornito nelle risorse aggiuntive.
Così, ora che abbiamo installato questi moduli nodo,
Mongoose e Mongoose valuta,
andiamo alla nostra applicazione e impostarlo per comunicare con il server MongoDB.
Ora, assicurati che il tuo server MongoDB sia attivo e funzionante.
Quindi, qui, vedi che
il mio server MongoDB è in esecuzione in un'altra scheda terminale sul mio computer.
Se lo si esegue su un computer Windows,
assicurarsi che sia in esecuzione in un altro comando Finestra del computer Windows.
Andando alla nostra applicazione nell'editor,
inizieremo prima con il file app.js.
Ora nel file app.js,
questo è dove abbiamo costruito la nostra applicazione espressa in precedenza.
Ma ora, questa negazione extra suck non è connessa al server back-end MongoDB.
Stiamo per fare uso del modulo Mongoose,
al fine di stabilire la connessione con il server.
Quindi, andando qui,
ho intenzione di aggiungere il modulo richiede il modulo Mangusta qui.
Quindi diremo: «Const Mangusta richiede Mangusta».
E poi anche, dal momento che abbiamo copiato sopra la cartella dei modelli,
che contiene il file piatti,
che dichiara lo schema dei piatti e il modello.
Quindi, fammi importare i piatti.
Quindi, diremo, «richiedere.Slash modelli piatti.»
Quindi, una volta completato questo, ora ovviamente,
dobbiamo stabilire la connessione con il server.
Quindi, imposta
l'URL mongodb// localhost7017/confusione,
proprio come abbiamo fatto con l'esercizio
Mangusta, e poi diremo, «Const connect, Mongo connect URL».
Quindi, questo è esattamente lo stesso codice che abbiamo usato nell'esercizio precedente.
Quindi, stabiliamo la connessione.
Quindi, diremo, «connect» e poi diremo,
«DB do it console log».
Dicendo: «Connesso correttamente al server».
E gestiremo anche l'errore qui.
Faremo semplicemente un registro della console dell'errore qui, il gioco è fatto.
Ciò stabilirà la connessione al server dal nostro file app.js.
Quindi, una volta stabilita la connessione al server,
quindi, apriamo il file dishes.js dai nostri modelli.
Ora, nel file dishes.js,
per fare uso
del modulo nodo che abbiamo appena installato.
Quindi, diremo, «Richiedi valuta Mangusta» e diciamo,
«Carica il tipo e la mangusta».
Quindi, ciò che questo farà è caricare questo nuovo tipo di valuta in Mongoose.
Successivamente, possiamo dire const,
valuta Mongoose tipi di valuta.
Questo è tutto. Quindi, questo nuovo tipo,
il tipo di valuta viene aggiunto in Mongusta e che aggiungerà un nuovo tipo chiamato
valuta e quindi così ho intenzione di dichiarare
questa valuta costante come valuta dei tipi di Mongusta.
In modo da poter fare uso di questo nella definizione dello schema nella mia applicazione.
Ora, in questo caso,
lo schema comune rimarrà esattamente lo stesso di prima, ma
lo schema piatto come si ricorda dal file db.json.
Quando si guarda la struttura di un documento piatto,
si vede che il documento piatto contiene nome e immagine che come si vede qui è una stringa,
una categoria, un'etichetta,
un prezzo, che è un tipo di stringa qui.
Ma dichiareremo questo come un tipo di valuta,
una caratteristica che come ci si aspetta è una variabile booleana,
e una descrizione che è una stringa e quindi commenti
che non è altro che un array di tipi di commenti.
Ora, quindi quello che faremo ora è estendere lo schema piatto per
supportare tutte queste varie proprietà o vari campi nel mio documento json.
Quindi abbiamo gia' il nome.
Quindi abbiamo già la descrizione in atto.
Quindi abbiamo bisogno di aggiungere nei prossimi lì abbiamo già i commenti,
la matrice di commenti del tipo di schema di commento lì.
Quindi aggiungeremo nei prossimi.
Quindi il prossimo che aggiungeremo è il tipo di immagine,
che sarebbe
della stringa di tipo e
diremo richiesto true.
Quindi questo aggiunge il tipo di immagine.
Il prossimo che aggiungerò è la categoria,
che è anche il tipo di stringa.
Il prossimo è l'etichetta,
che è anche questo tipo di stringa.
Dal momento che tutti questi sono dello stesso tipo e richiesti,
li sto solo copiando qui.
Quindi per l'etichetta,
direi che questo non è richiesto, ma
invece posso anche specificare un valore predefinito se voglio.
Quindi posso specificare un valore predefinito come quello.
Il valore predefinito è una stringa vuota.
Quindi, se non specifico richiesto, posso semplicemente specificare un valore predefinito qui.
Ora, in aggiunta, il prossimo campo che ho intenzione di introdurre è il campo dei prezzi.
Il campo prezzo dichiarerò il tipo come valuta.
Ricordiamo che avevamo dichiarato il tipo di valuta in precedenza
qui richiedendo prima
il modulo di valuta Mongoose e quindi dichiarando il tipo di valuta.
Quindi, è così che useresti il tipo di valuta nella nostra applicazione.
Quindi diremo tipo di prezzo valuta e
richiesto è vero e quindi posso anche specificare il valore minimo che sarebbe zero.
Quindi il campo successivo è
il campo in primo piano che sarebbe del tipo booleano,
e il valore predefinito sarà falso.
Quindi, se il mio documento manca,
allora il valore predefinito verrà aggiunto nel documento qui.
Quindi notare che ora ho ampliato
lo schema piatto aggiungendo il tipo di immagine, la categoria,
l'etichetta, il prezzo e la caratteristica per abbinare
la struttura dell'esempio di documento piatto che vi ho appena mostrato in precedenza.
Così ora, il mio schema di piatti è tutto pronto per essere utilizzato.
Quindi, iniziamo ora a lavorare sul mio router.
Allora, dov'è il router?
Si ricorda che il router che supporta gli endpoint API REST per le slash dish,
endpoint API REST e piatti barra,
endpoint dell'ID piatto barra è nel router piatto.
Quindi, andremo a piatto router.jsfile e poi estenderemo il file piatto router.js.
Quindi, nel router piatto insieme a Express e BodyParser,
ora includerò Mongoose.
Quindi diremo richiedono Mangusta e
poi avremo bisogno di piatti modello.
Dov'è il modello dei piatti?
È dentro. /modelli/piatti.
Quindi è lì dentro.
Quindi nota che siamo nella cartella del router,
quindi devi salire di un livello e quindi andare nella
cartella del modello e quindi il file dishes.js è proprio lì.
Questo è ciò che stiamo importando qui.
Così ora, posso aggiornare il mio router piatto per essere in grado di interagire
con il server MongoDB usando
Mongoose e abbiamo già importato il modello di piatti nel mio router piatto.
Quindi, è tempo per me di andare e aggiornare tutti i metodi qui dentro.
Quindi, per il router piatto,
la barra che significa che la barra piatti endpoint.
Ho intenzione di rimuovere tutto questo da qui, invece,
ho intenzione di dichiarare esplicitamente tutti i vari endpoint.
Per ottenere post put ed delete gestirò ognuno di loro in modo indipendente.
Quindi nel metodo get,
ho intenzione di ritagliarlo e poi nel metodo get, cosa devo fare?
Ricordiamo che avevamo definito il metodo da Mangusta che ci permette di trovare tutti i piatti.
Quindi, quando si esegue un'operazione get sull'endpoint slash dish,
ci si aspetta che tutti i piatti vengano restituiti
al client in risposta alla richiesta get.
Quindi, vado ai piatti e poi eseguirò l'operazione di ricerca.
Quindi ora lo vedi dal mio server Express,
sto accedendo al mio MongoDB.
Quindi, farò una scoperta e nel ritrovamento ora gestirò la richiesta.
Quindi posso dire che i piatti trovano,
dato che sta per restituire una promessa,
allora posso gestirlo qui dentro.
Quindi, dirò piatto e quindi se la promessa si risolve correttamente,
lo farò in poi e così dirò piatto e poi così gestiremo il
codice di stato res è 200 e poi diremo
res impostare tipo di contenuto intestazione.
Dal momento che stiamo andando a restituire il valore come un json,
quindi lo imposteremo su applicazione json.
Ok, questo restituira' una serie di piatti.
Quindi posso semplicemente dire piatti e poi diremo res.json.
Quindi il res.json prenderà come input nella stringa json
e quindi lo invierà al mio client.
Quindi, quando chiami res.json e fornisci il valore e poi
prenderà semplicemente il parametro che fornisci qui e poi lo invii come risposta json.
Inserirà questi piatti nel corpo del
messaggio di risposta e quindi lo invierà nuovamente al server.
Ora, possiamo gestire l'errore
qui dicendo il prossimo errore.
Possiamo anche fare un errore di cattura solo per il bene del completo.
Ho intenzione di mettere entrambi questi a posto qui, in
modo che entrambi saranno gestiti come tali.
Quindi, se viene restituito un errore,
questo passerà semplicemente l'errore al
gestore degli errori generale per la mia applicazione
e il lasciar che si preoccupi di come gestire l'errore.
Quindi lo manderemo a quello.
Quindi vedi come sto usando l'operazione di ricerca e quindi eseguo la richiesta qui.
Ora, per il post,
come ti saresti già aspettato,
ho intenzione di fare piatti.create
perché stiamo andando a creare un nuovo piatto qui.
Quindi, ricorda che abbiamo già visto i piatti creano l'
utilizzo del metodo in precedenza e ricorda che il parser del corpo avrebbe
già analizzato tutto ciò che è nel corpo del messaggio e lo ha caricato
sulla proprietà body della richiesta.
Quindi, ho intenzione di prendere il corpo della richiesta e quindi analizzarlo come parametro per il mio
metodo dishes.create e gestire il valore restituito.
Quindi, diremo allora e questo restituirebbe
un piatto e ce ne occuperemo qui.
Quindi diremo se i piatti tornano correttamente e se i piatti postati correttamente, dirà res.
Ok facciamo un console.log per il nostro utilizzo.
Sul lato server faremo un console.log dicendo piatto «Dish Created» qui.
Registriamo quel piatto sulla console e poi diremo questi due codici di stato di riposo.
Copieremo quel codice e lo incolleremo lì dentro e in questo caso,
restituiremo il piatto qui.
Il piatto che è arrivato come parametro qui e poi lascia che
il cliente si occupi di quel valore sul lato client,
qualunque cosa venga restituito nel piatto.
Ora, anche loro aggiungeranno in
questo qui e poi la cattura.
Quindi questo è il modo in cui gestiamo il post.
Per il PUT, perché PUT non è consentito,
quindi lo lasceremo come tale.
Per DELETE, stiamo per eliminare tutti i piatti.
Quindi diremo, «piatti.Rimuovere».
Questa è essenzialmente un'operazione pericolosa.
Così si sta rimuovendo tutti i piatti
dal server e così diremo,
«piatti.Rimuovere allora» e il «allora» otterrà una certa risposta.
Quindi diremo semplicemente «resp here» e il modo in cui gestiremmo
quella risposta è semplicemente prendere quel valore e poi restituirlo al client.
Quindi diremo, «res.statusCode 200 content type application json», e
quindi invieremo semplicemente la risposta al client e gestiremo l'errore
proprio come abbiamo fatto in precedenza.
Questa è l'operazione DELETE.
Quindi vedete che ora stiamo facendo l'
operazione GET, POST, PUT e DELETE.
Ora continueremo lo stesso con il punto finale /dishID.
Quindi in questo caso,
siamo specificamente motivo ottenere un piatto specifico.
Restituiremo quel valore specifico del piatto.
Quindi nel GET,
quello che facciamo è diremo «piatti.FindById.
Quindi il findById è un metodo che è disponibile da mongo e dal driver MongoDB.
Quindi diremo,» req.params.dishid.»
Ricordiamo che sappiamo già che l'ID piatto è presente nella proprietà params.
Avete già imparato a questo proposito in precedenza.
Quindi dirò, «findById (req.params.dishId)» e
poi e il resto.
Quindi ho intenzione di copiare quello poi e altro da proprio
lì e poi scendere al DishRouter e
poi semplicemente incollarlo qui.
Quindi diremo, "res.statusCode200
applicazione json.res.jsondish e quindi la gestione degli errori.
Per il POST, ovviamente non gestiremo il post per un endpoint /dishID.
Quindi lo lasceremo come tale.
Per PUT, stiamo per aggiornare
un piatto specifico che è identificato dal suo ID piatto.
Quindi questo è dove useremo dishes.FindByidAndUpdate.
Quindi questo è il metodo che useremo,
findByidAndUpdate e questo prende come primo parametro
req.params.dishId e il secondo valore è
l'insieme e l'aggiornamento
sarà nel corpo del messaggio.
Quindi ho intenzione di recuperarlo
dal corpo req e poi anche dall'altra bandiera che ho intenzione di avere.
Quindi dirà «new: true», in modo che questo metodo findById restituisca
il piatto aggiornato come stringa json nella risposta.
Quindi questo è quello che ho intenzione di ottenere qui e poi quando quel valore entra in gioco,
ho solo intenzione di prendere il piatto e
poi semplicemente di restituire il piatto al lato cliente.
Quindi dirò res.jason (piatto) e poi gestiremo l'errore in modo corrispondente.
Finalmente per il DELETE.
Per il DELETE di nuovo,
il metodo corrispondente che stiamo per
utilizzare è il metodo di Mongo chiamato FindByIdAndRemove.
Quindi puoi vedere che abbiamo questo metodo chiamato
findByidAndRemove e questo findByidAndRemove,
prenderà req.params.dishID perché questo è il piatto che stiamo cercando di rimuovere.
Quindi, quando questo viene eliminato,
così come abbiamo gestito questo qui,
quindi ho intenzione di copiare questo codice dai dishes.Remove.
E' la stessa cosa che faro' anche qui.
Quindi findByidAndRemove e qualunque risposta
ottengo, lo restituirò al mio cliente.
Con questo abbiamo aggiornato il DishRouter.
Salviamo tutte le modifiche che abbiamo fatto
finora e poi andremo ad avviare il nostro server e poi vedere cosa fa.
Quindi andando al terminale o alla finestra di comando, avvia il server.
Quindi dirò «npm start» e il server è ora attivo e funzionante.
Useremo il postino per comunicare con questo server.
Quindi andiamo al postino e poi eseguiamo alcune operazioni.
Quindi qui vedete il mio postino che corre qui.
Quindi fammi fare un'operazione GET sul localhost: 3000/piatti.
Quindi, quando esegui un'operazione GET come vedi,
restituirà una stringa vuota.
Il mio database è ora vuoto, quindi non ho nulla lì.
Quindi mi verrà restituita una stringa vuota.
Mettiamo un piatto.
Quindi, quando pubblichi un piatto,
ovviamente nel corpo,
racchiuderai un piatto e il corpo sarà impostato per essere il tipo json dell'applicazione.
Ora, per pubblicare un piatto,
ti ho già dato il file db.json nelle risorse di esercizio.
Quindi apri il file db.json e poi copia il primo piatto da
lì e poi lo incolleremo qui e poi pubblicheremo quel piatto.
Quindi, lasciami andare al file db.jason.
Fammi copiare il primo piatto da qui.
Quindi ho intenzione di copiare
l'intero piatto fino a lì e poi ho intenzione di postare questo piatto.
Questo contiene molti dei campi che abbiamo già qui.
Diamo questo piatto al server e vediamo cosa succede.
Quindi tornando al postino.
Qui, nei dati del modulo,
nel corpo, lasciami incollare il piatto in posizione.
Quindi, abbiamo i dettagli completi del piatto lì.
POSSIAMO questo piatto al server.
Poi, una volta che il piatto è stato pubblicato sul server,
vedi che il Postman ha,
fammi solo ridurre questo,
e poi vedi in fondo che questo particolare piatto è stato pubblicato nel database,
nel database MongoDB dal mio server.
Quindi, vedi che il valore restituito
qui mostra quando il piatto è stato inserito in quel server.
Quindi, hai aggiunto CreateDat e UpdateDat.
Si vede che i campi rimanenti sono tutti memorizzati lì.
Nota in particolare come il valore del prezzo viene memorizzato lì.
Questo è il modo in cui valuta memorizza il valore del prezzo.
Quindi, quando ottieni il valore di ritorno,
devi interpretarlo in modo appropriato sul lato client cosa significa.
Si noti inoltre che l'ID è stato aggiunto al mio piatto e per ogni commento stesso,
perché ognuno dei commenti è di per sé è un sottodocumento.
Avrai aggiunto UpdateDat e CreateDat
e l'ID per ciascuno dei commenti anche aggiunto automaticamente dal mio database.
Ecco a te. Quindi ora,
questo piatto è stato aggiunto al mio database.
Eseguiamo di nuovo l'operazione GET,
e ovviamente a questo punto,
il server dovrebbe restituire quel piatto particolare che è stato aggiunto in.
Quindi, restituirà una serie di piatti qui,
quindi, come puoi vedere, restituisce una serie di piatti.
Naturalmente, questa matrice contiene solo un piatto
o quel piatto particolare è stato restituito qui.
Finora, così bene.
Quindi, facciamo un PUT sui piatti e vediamo cosa succede.
Quando fai un PUT, ovviamente, dice,
«operazione PUT non supportata sui piatti», come ci aspettiamo.
Facciamo un DELETE.
Facendo un'operazione DELETE,
restituisce questa risposta dicendo,
«N è uguale a uno», ok,
uno significa che ha cancellato un piatto.
Facciamo ora di nuovo, eseguire un'operazione GET,
e poi si vedrebbe che i miei piatti sono vuoti come ci aspettavamo.
Quindi, vedi che le
operazioni GET, PUT, POST e DELETE funzionano tutte correttamente.
Ora, lasciami POST il piatto
di nuovo sul server perché voglio avere un piatto nel server.
Quindi, lasciami POST quel piatto,
e noterai che l'ID è ora cambiato.
Quindi, lasciami selezionare quell'ID,
e poi faremo un GET con l'ID in atto.
Quando fai un GET con l'ID in posizione,
vedi che restituisce quel piatto specifico come te lo aspetti.
Andiamo al terminale e vediamo cosa
viene stampato sul terminale o sulla finestra di comando.
Quindi, andando al terminale o alla finestra di comando,
vedi che sta stampando tutte queste cose sulla finestra di comando.
Quindi, quando abbiamo fatto la prima operazione GET,
dice, GET /dish.
Quindi, questo è di nuovo,
Morgan sta facendo questo lavoro per te, sta stampando,
tracciando queste informazioni e dice piatto creato
e poi quella particolare informazione piatto è stata stampata,
e poi dice POST /piatti, GET/piatti,
e poi quando hai fatto un PUT ha restituito un 403
lì e hai creato di nuovo piatti e così via.
Quindi, vedi che il tuo server sta effettivamente facendo tutto il lavoro
e queste cose vengono inserite nel tuo database MongoDB come ti aspettavi.
Ora, tornando al postino,
facciamo un POST sui piatti.
Ora, questo non è supportato sul lato server,
quindi il server dovrebbe dire
«L'operazione POST non è supportata su quel particolare endpoint», come ci si può aspettare.
Facciamo un'operazione PUT.
Quando esegui un'operazione
PUT, quello che farò nell'operazione PUT è che
sostituirò l'etichetta lì dentro.
Quindi, nel mio corpo del messaggio.
Quindi, ricorda che se guardi il file db.json,
l'etichetta per quello sarebbe nuova,
e quindi cambierò quell'etichetta in hot.
Dal momento che questo deve essere in Json,
quindi etichetta anche tra virgolette etichetta Json hot,
e quindi facciamo un PUT su quel particolare endpoint.
L' operazione PUT ha avuto esito positivo
e quindi si vede che quando l'operazione PUT è stata eseguita,
si noterà che l'etichetta ora è cambiata da nuova a hot qui,
e si noti in particolare, il valore
CreatedAt e il valore UpdateDat.
Quindi, si noti che questo record è stato creato
in questo momento ed è stato aggiornato un po 'più tardi.
Quindi, l'aggiornamento è stato fatto dall'operazione PUT che ho appena
eseguito su quel piatto particolare.
Cancelliamo il piatto.
Questo è permesso. Quindi, cancelleremo il piatto,
quindi il piatto verrà cancellato e il valore verrà restituito.
Ora, se si esegue un'operazione GET
sull'endpoint piatti, si vedrà che questo restituirà un vuoto.
Quindi, sei appena riuscito a cancellare il piatto dal nostro database.
Quello che ho intenzione di fare è eseguire
un'operazione GET su un piatto inesistente e vedere cosa succede.
Quando eseguo un'operazione GET su un piatto inesistente,
restituisce null perché quel piatto non esiste.
Quindi, restituisce un valore nullo che dice che il piatto non esiste.
Ora, lasciami eseguire un'operazione GET su un non-ObjectID e vedere cosa succede.
Ritorna come vedi.
Fammi vedere in anteprima.
Quindi, dice, «Cast to ObjectID fallito per valore qui al percorso.»
Quindi, sarò ovviamente questo non è
un ObjectID valido, quindi sono riuscito a eliminarne parte,
e quindi eseguire l'operazione in modo che restituisca un errore dicendo,
quindi vedi che c'è 500 errore interno del server.
Il server non è stato in grado di gestire questo e quindi restituire questo valore qui.
Quindi, dice: «No,
questo non è permesso».
Quindi, perché questo non è un ObjectID valido.
Quindi, anche gli errori vengono gestiti in modo appropriato come vedi qui.
Quindi, lasciami di nuovo, fai un'operazione GET sui piatti
e il tuo server è ancora in esecuzione
e restituirà un valore vuoto qui.
Così, abbiamo visto come modificando
il nostro server API REST per essere in grado di interagire con il server MongoDB.
Ora abbiamo un server API REST a tutti gli effetti che è in grado di memorizzare
, recuperare ed eseguire varie operazioni
sui dati memorizzati sul mio server MongoDB.
Con questo, completiamo questo esercizio.
Quindi, in questo esercizio,
abbiamo visto come siamo in grado di interagire con il nostro server API REST,
e, a sua volta, con il server MongoDB,
e quindi stiamo sfruttando il server MongoDB per memorizzare e recuperare i dati dal server.
Sei in grado di interagire dalla
nostra applicazione Express con il server MongoDB utilizzando Mongoose.
Questo è un buon momento per fare un commit GIT con il messaggio,
«API REST Express with Mongoose Part One».