‫Istruttore: Proprio come
‫Express, anche Mongoose ha il concetto di middleware.
‫E così ora impariamo a conoscere il
‫primo tipo di middleware, che è il middleware dei documenti.
‫Ora, proprio come con Express, possiamo usare
‫il middleware Mongoose per far succedere qualcosa
‫tra due eventi.
‫Ad esempio, ogni volta che un nuovo
‫documento viene salvato nel database, possiamo
‫eseguire una funzione tra il comando di salvataggio e
‫l'effettivo salvataggio del documento, oppure anche dopo l'effettivo salvataggio.
‫E questo è il motivo per cui
‫il middleware Mongoose è anche chiamato pre e post hook.
‫Ancora una volta, perché possiamo definire funzioni
‫da eseguire prima o dopo un determinato evento, come
‫salvare un documento nel database.
‫Quindi il middleware è un concetto assolutamente fondamentale in
‫Mongoose, proprio come in Express.
‫E ci sono un sacco di
‫possibilità e casi d'uso per il middleware, e
‫useremo il middleware tutto il tempo in questo progetto.
‫Quindi ci sono quattro tipi di middleware
‫in Mongoose: documento, query, aggregazione e middleware di modello.
‫E in questa lezione
‫parleremo del middleware del documento, che
‫è un middleware che può agire sul documento attualmente elaborato.
‫Quindi, proprio come le proprietà virtuali,
‫definiamo un middleware sullo schema,
‫quindi tourSchema. pre.
‫E quindi questo è per il pre middleware, che di
‫nuovo verrà eseguito prima di un evento reale.
‫E quell'evento in questo caso è l'evento di salvataggio.
‫E quindi questa funzione di richiamata
‫che definiremo qui
‫di seguito,
‫quindi funzione in modo che questa funzione venga chiamata prima che un
‫documento effettivo venga salvato nel database.
‫Quindi questo è il middleware dei documenti e
‫funziona, lasciami scrivere tutto qui.
‫Quindi viene eseguito prima del comando save
‫e del . comando crea.
‫Ma non su inserire molti.
‫Quindi, se usiamo questo comando qui, quindi insertMany, in realtà
‫non attiverà il middleware di salvataggio.
‫Quindi tienilo sempre a mente.
‫È molto importante rendersi conto che solo al
‫salvataggio e alla creazione questo middleware
‫verrà eseguito.
‫E quindi iniziamo facendo una semplice console. log e quello
‫che registrerò tramite la console è questo.
‫E così in un middleware di salvataggio, la parola
‫chiave disk qui punterà al documento attualmente elaborato.
‫E questo è il motivo per cui viene chiamato middleware di documenti.
‫Di nuovo, perché in questa
‫funzione qui abbiamo accesso al documento che viene elaborato.
‫Quindi, in questo caso, il documento che viene salvato.
‫E quindi lascia che te lo mostri molto rapidamente usando
‫questa console. tronco d'albero.
‫Quindi, per attivare ora questa funzione,
‫ricorda che dobbiamo eseguire un comando di salvataggio o un comando di creazione.
‫E quindi ora dobbiamo creare un nuovo tour usando la
‫nostra API per, sì, per poi attivare questo middleware.
‫Quindi andiamo qui, al postino, e comincerò salvando questi due
‫nuovi percorsi che abbiamo creato
‫nelle lezioni precedenti, quindi prendi un piano mensile.
‫E questo qui è ottenere le statistiche del tour.
‫Quindi ora posso chiuderli e creare un nuovo tour.
‫E specifichiamo i dati qui nel corpo.
‫Ora non tutte le cose qui sono effettivamente necessarie,
‫quindi diamo un'occhiata a ciò che è
‫effettivamente richiesto e liberiamoci del resto.
‫Quindi è necessaria l'immagineCover,
‫il riepilogo, ovviamente il prezzo e sì.
‫Quindi liberiamoci delle cose di cui non
‫abbiamo davvero bisogno qui solo per mantenerle al minimo.
‫Quindi le valutazioni, la quantità, la media, quindi queste
‫non sono necessarie.
‫Quindi chiamerò questo
‫qui il tour di prova, solo per renderlo davvero semplice qui.
‫Ora inviamo questa richiesta e infatti, ha creato
‫il nuovo documento e ora diamo
‫un'occhiata alla nostra console e vediamo quel documento qui.
‫E infatti, eccolo qui.
‫Quindi aumentiamo un po' questo qui
‫e quindi questo è l'aspetto del nostro
‫documento appena prima di essere salvato nel database.
‫E quindi qui abbiamo valutazioniMedia e quantità, che sono
‫impostate per impostazione predefinita.
‫Ricorda, quindi 4. 5 e zero, e
‫poi il timestamp createAt, e puoi anche vedere
‫la proprietà virtuale che abbiamo definito qui.
‫Quindi, di nuovo, questo è giusto prima di
‫salvare effettivamente questi dati nel database.
‫Quindi, a questo punto,
‫possiamo ancora agire sui dati prima che vengano salvati
‫nel database ed è esattamente quello che
‫faremo ora.
‫Quindi quaggiù nella nostra funzione middleware.
‫E quello che voglio fare qui è creare una
‫lumaca per ciascuno di questi documenti.
‫Quindi ricorda come nella prima sezione
‫abbiamo creato una lumaca per ciascuno dei prodotti
‫che avevamo nel negozio.
‫E quindi una lumaca è fondamentalmente solo
‫una stringa che possiamo inserire nell'URL, di solito basata su
‫una stringa come il nome.
‫Quindi, in questo caso, creeremo una lumaca basata
‫qui sul nome del tour.
‫Quindi ricorda come per questo abbiamo usato il pacchetto slugify.
‫E quindi ora andiamo avanti e installiamolo.
‫Va bene, e mentre ciò
‫accade, andiamo avanti e poi richiediamolo qui.
‫Quindi richiedono slugify.
‫Torniamo alla nostra prima finestra qui, in realtà.
‫E ora, quaggiù, non vogliamo
‫più registrarlo sulla console.
‫Ma invece ora possiamo dire questo, e ricorda,
‫questo è il documento attualmente elaborato.
‫Quindi ora possiamo definire una nuova proprietà su di esso.
‫Ed è esattamente quello che sto facendo.
‫Così questo. slug dovrebbe essere slugify,
‫e quindi solo una stringa da cui
‫vogliamo creare uno slug, e quindi sarà questo. name e poi vogliamo anche passare
‫nell'opzione che tutto dovrebbe
‫essere convertito in minuscolo, e quindi questo
‫è più basso: vero, e ora gli darò un salvataggio.
‫E una cosa di cui
‫non abbiamo ancora parlato è la funzione successiva.
‫Quindi, proprio come in Express, abbiamo anche la funzione successiva
‫nel middleware mMngoose, fondamentalmente per chiamare il prossimo
‫middleware nello stack come già sappiamo.
‫Ora, in questo caso, abbiamo solo una funzione
‫middleware, motivo per cui non abbiamo
‫riscontrato alcun problema, nemmeno chiamando next, ma ora facciamolo.
‫E così ogni funzione middleware, in
‫un middleware pre-salvataggio, ha accesso a quella successiva.
‫Quindi è esattamente lo stesso di Express, e
‫quindi entro la fine del middleware chiamiamo next, e
‫questo chiamerà il prossimo middleware
‫nello stack.
‫Quindi proviamo di nuovo.
‫E questo si chiamerà test tour numero due.
‫Molto semplice, manda in
‫cielo, e aspettiamo.
‫E ora, per qualche ragione, non è proprio qui.
‫Vediamo se abbiamo avuto qualche errore, e
‫in realtà non l'abbiamo fatto.
‫Ma il motivo per cui non funziona
‫è che in questo momento non abbiamo alcuna lumaca nel nostro schema.
‫E ricorda che questo ci è successo prima quando avevamo
‫solo un paio di campi nello schema.
‫E quando noi, allora definiremo
‫alcuni campi che non erano nello schema,
‫quindi semplicemente non erano mantenuti nel database.
‫E la stessa cosa sta succedendo qui,
‫quindi abbiamo definito la proprietà slug, ma non è nel nostro schema.
‫E quindi non è stato salvato nel database, quindi risolviamolo
‫rapidamente e mettiamolo, oh, non lo so, non
‫ha molta importanza, possiamo metterlo qui
‫subito dopo il nome,
‫quindi la lumaca dovrebbe essere semplicemente una stringa.
‫E quindi dovrebbe risolverlo.
‫Quindi torniamo indietro e creiamo il tour di prova numero tre.
‫Perché non può essere lo stesso, perché ricorda che
‫non possiamo avere tour con lo stesso nome.
‫Quindi fallo di nuovo, e ora in effetti abbiamo la proprietà
‫slug proprio qui ed è davvero basata sul nome, come
‫puoi vedere qui.
‫Ottimo, quindi torniamo qui, riduciamo
‫questo un po'.
‫E così qui abbiamo il middleware pre-documento.
‫Sperimentiamo ora molto velocemente anche con
‫un post middleware.
‫Quindi tourSchema. posta e usiamo di nuovo save.
‫E poi la funzione di callback, che nel caso
‫di post middleware ha accesso
‫non solo al next, ma anche al
‫documento che è stato appena salvato nel database.
‫Quindi chiamiamolo un documento e poi il prossimo.
‫E così le funzioni post middleware vengono
‫eseguite dopo che tutte le funzioni pre middleware
‫sono state completate, va bene.
‫Quindi qui in realtà non abbiamo più la parola chiave
‫disk, ma abbiamo invece il documento sostanzialmente
‫finito qui in doc.
‫Quindi registriamo il documento finito sulla console
‫e poi chiamiamo next.
‫Anche in questo caso, abbiamo
‫solo un middleware post e quindi non avremmo bisogno
‫di quello successivo, ma è una buona pratica includerlo sempre.
‫Un'altra cosa che volevo mostrarvi è che possiamo
‫avere, ovviamente, più middleware
‫pre o anche post middleware per lo stesso hook.
‫E hook è ciò che chiamiamo questo salvataggio qui.
‫Quindi questo middleware qui è
‫fondamentalmente ciò che chiamiamo hook pre-salvataggio.
‫Quindi vedrai quella terminologia tutto il tempo.
‫Quindi alcuni lo chiamano middleware e altri lo chiamano hook.
‫E quindi questo sarà un hook pre-salvataggio
‫o un middleware pre-salvataggio.
‫Quindi funzione, e questo ha accesso al prossimo.
‫E quindi registriamo qui
‫qualcosa sulla console, ad esempio salverà il documento.
‫E poi il prossimo, e quello, ovviamente, dovrebbe essere il prossimo.
‫Giusto per vedere se otteniamo
‫qualche errore, ometterò il prossimo qui.
‫Giusto per vedere cosa succede quando non lo chiamiamo.
‫Quindi creerò un nuovo
‫tour ed entro la fine di questa
‫lezione li cancellerò tutti, ma per ora ne abbiamo bisogno qui.
‫E così ora vedi che non sta finendo davvero, quindi
‫siamo bloccati in quella funzione middleware che non
‫ha la chiamata successiva.
‫Quindi in pratica siamo bloccati qui.
‫Quindi annulliamo la
‫richiesta e poi la riportiamo qui
‫e riproviamo.
‫E così ora funzionava davvero.
‫Quindi il nostro slug è qui, giusto, e quindi diamo
‫un'occhiata alla nostra console, e quindi in
‫effetti, anche il nostro secondo middleware pre viene eseguito,
‫quindi l'unico logging salverà il documento e poi
‫il nostro middleware post quindi accedi alla console il documento
‫finale, e quindi anche quello
‫dovrebbe già avere la lumaca e sì, eccolo qui.
‫E questo è tutto ciò
‫che avevo da mostrarti sul middleware dei documenti.
‫Ora commenterò questi due qui perché non
‫voglio inquinare il mio log qui tutto il tempo con
‫queste console. log, ma li
‫tengo ancora qui, di nuovo,
‫come riferimento.
‫Quindi quello che voglio che ricordiate da questa lezione
‫è che possiamo avere un middleware in esecuzione prima
‫e dopo un determinato evento.
‫E nel caso del middleware
‫del documento, quell'evento è solitamente l'evento di salvataggio.
‫E poi nella stessa funzione middleware, abbiamo accesso
‫alla parola chiave disk, che
‫punterà al documento attualmente in fase di salvataggio.
‫Ed è anche molto importante tenere
‫presente che questo middleware di salvataggio viene eseguito solo per il salvataggio e
‫la creazione di metodi Mongoose.
‫Non verrà eseguito, ad esempio, per inserire molti
‫e nemmeno per trovarne uno e aggiornare
‫o trovare per ID e aggiornare, che abbiamo già usato prima.
‫Quindi, per esempio, da qualche parte
‫qui abbiamo findByIdAndUpdate, ma questo non attiverà questo
‫middleware di salvataggio.
‫Quindi è molto importante tenerlo a mente perché
‫in realtà un po'
‫più avanti in questo progetto dovremo aggirare questa limitazione.
‫Va bene, quindi questo è un
‫middleware di documenti per manipolare i documenti che vengono attualmente salvati.
‫Successivamente, parleremo del middleware di query.