Koa.js - Database

Stiamo ricevendo le richieste, ma non le stiamo archiviando da nessuna parte. Abbiamo bisogno di un database per memorizzare i dati. Useremo un famoso database NoSQL chiamatoMongoDB. Per installare e leggere informazioni su Mongo, vai a questo link.

Per poter utilizzare Mongo con Koa, abbiamo bisogno di un'API client per il nodo. Ci sono più opzioni per noi, tuttavia per questo tutorial ci atteneremo alla mangusta . La mangusta è usata perdocument modelingin Node for MongoDB. La modellazione del documento significa che creeremo un fileModel (molto simile a un file class nella programmazione orientata ai documenti), e poi produrremo documents utilizzando questo modello (come creiamo documents of a classin OOP). Tutta la nostra elaborazione verrà eseguita su questi "documenti", quindi, infine, scriveremo questi documenti nel nostro database.

Impostazione della mangusta

Ora che abbiamo installato Mongo, installiamo mongoose, nello stesso modo in cui abbiamo installato gli altri nostri pacchetti di nodi.

$ npm install --save mongoose

Prima di iniziare a usare mongoose, dobbiamo creare un database usando la shell Mongo. Per creare un nuovo database, apri il tuo terminale e inserisci "mongo". Verrà avviata una shell Mongo, immettere quanto segue.

use my_db

Verrà creato un nuovo database per te. Ogni volta che apri la shell Mongo, per impostazione predefinita "test" db e dovrai passare al tuo database usando lo stesso comando di cui sopra.

Per usare mongoose, lo richiederemo nel nostro file app.js e poi ci collegheremo al servizio mongod in esecuzione su mongodb: // localhost

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

app.use(_.routes());
app.listen(3000);

Ora la nostra app è collegata al nostro database, creiamo un nuovo modello. Questo modello fungerà da raccolta nel nostro database. Per creare un nuovo modello, utilizzare il codice seguente, prima di definire qualsiasi percorso.

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.use(_.routes());
app.listen(3000);

Il codice precedente definisce lo schema per una persona e viene utilizzato per creare un modello di mangusta Person.

Salvataggio di documenti

Ora creeremo un nuovo modulo html, che otterrà i dettagli di una persona e lo salverà nel nostro database. Per creare il modulo, crea un nuovo file di visualizzazione chiamato person.pug nella directory delle visualizzazioni con il seguente contenuto.

html
   head
      title Person
   body
      form(action = "/person", method = "POST")
         div
            label(for = "name") Name: 
            input(name = "name")
         br
         div
            label(for = "age") Age: 
            input(name = "age")
         br
         div
            label(for = "nationality") Nationality: 
            input(name = "nationality")
         br
         button(type = "submit") Create new person

Aggiungi anche un nuovo percorso get in index.js per eseguire il rendering di questo documento.

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

_.get('/person', getPerson);

function *getPerson(next){
   this.render('person');
   yield next;
}

app.use(_.routes());
app.listen(3000);

Vai a localhost: 3000 / persona per verificare se il nostro modulo viene visualizzato correttamente. Nota che questa è solo l'interfaccia utente, non funziona ancora. Ecco come appare la nostra forma.

Definiremo ora un gestore di post route in "/ person" che gestirà questa richiesta.

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

_.post('/person', createPerson);

function *createPerson(next){
   var self = this;
   var personInfo = self.request.body; //Get the parsed information
   
   if(!personInfo.name || !personInfo.age || !personInfo.nationality){
      self.render(
         'show_message', {message: "Sorry, you provided wrong info", type: "error"});
   } else {
      var newPerson = new Person({
         name: personInfo.name,
         age: personInfo.age,
         nationality: personInfo.nationality
      });
      yield newPerson.save(function(err, res) {
         if(err)
            self.render('show_message', 
               {message: "Database error", type: "error"});
         else
            self.render('show_message', 
               {message: "New person added", type: "success", person: personInfo});
      });
   }
}

app.use(_.routes());
app.listen(3000);

Nel codice sopra, se riceviamo un campo vuoto o non riceviamo alcun campo, invieremo una risposta di errore. Tuttavia, se riceviamo un documento ben formato, creiamo un documento newPerson dal modello Person e lo salviamo nel nostro DB utilizzandonewPerson.save()funzione. Questo è definito in mongoose e accetta un callback come argomento. Questo callback ha due argomenti,error e response. Questo renderà la vista show_message, quindi dobbiamo creare anche quella.

Per mostrare la risposta da questo percorso, dovremo anche creare un file show_messageVisualizza. Crea una nuova vista con il codice seguente.

html
   head
      title Person
   body
      if(type = "error")
         h3(style = "color:red") #{message}
      else
         h3 New person, name: 
            #{person.name}, age: 
            #{person.age} and nationality: 
            #{person.nationality} added!

Di seguito è riportata la risposta che riceviamo dopo aver inviato con successo il modulo (show_message.pug).

Ora abbiamo un'interfaccia per creare persone!

Recupero di documenti

Mongoose fornisce molte funzioni per il recupero dei documenti, ci concentreremo su tre di queste. Tutte queste funzioni accettano anche un callback come ultimo parametro e, proprio come la funzione di salvataggio, i loro argomenti sono errore e risposta.

Le tre funzioni sono:

Model.find (condizioni, richiamata)

Questa funzione trova tutti i documenti che corrispondono ai campi nell'oggetto condizioni. Gli stessi operatori usati in Mongo funzionano anche con la mangusta. Ad esempio, questo recupererà tutti i documenti dalla raccolta delle persone.

Person.find(function(err, response){
   console.log(response);
});

Questo recupererà tutti i documenti in cui il nome del campo è "Ayush" e l'età è 20.

Person.find({name: "Ayush", age: 20}, 
   function(err, response){
      console.log(response);
   });

Possiamo anche fornire la proiezione di cui abbiamo bisogno, cioè i campi di cui abbiamo bisogno. Ad esempio, se vogliamo solo il filenames delle persone di cui nationalityè "indiano" , usiamo -

Person.find({nationality: "Indian"}, 
   "name", function(err, response) {
      console.log(response);
   });

Model.findOne (condizioni, richiamata)

Questa funzione recupera sempre un unico documento più rilevante. Ha gli stessi argomenti esatti di Model.find ().

Model.findById (id, callback)

Questa funzione accetta l'estensione _id(definito da mongo) come primo argomento, una stringa di proiezione opzionale e un callback per gestire la risposta. Per esempio,

Person.findById("507f1f77bcf86cd799439011", 
   function(err, response){
      console.log(response);
   });

Creiamo un percorso per visualizzare tutti i record delle persone.

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

_.get('/people', getPeople);
function *getPeople(next){
   var self = this;
   
   yield Person.find(function(err, response){
      self.body = response;
   });
}
app.use(_.routes());
app.listen(3000);

Aggiornamento dei documenti

Mongoose fornisce tre funzioni per aggiornare i documenti.

Model.update (condizione, aggiornamenti, richiamata)

Questa funzione accetta una condizione e aggiorna l'oggetto come input e applica le modifiche a tutti i documenti che corrispondono alle condizioni nella raccolta. Ad esempio, il codice seguente aggiornerà tutti i documenti Person per avere una nazionalità "americana".

Person.update({age: 25},
   {nationality: "American"}, 
   function(err, response){
      console.log(response);
   });

Model.findOneAndUpdate (condizione, aggiornamenti, richiamata)

Fa esattamente quello che dice. Trova un documento in base alla query e lo aggiorna in base al secondo argomento. Accetta anche un callback come ultimo argomento. Per esempio,

Person.findOneAndUpdate({name: "Ayush"}, 
   {age: 40}, 
   function(err, response){
      console.log(response);
   });

Model.findByIdAndUpdate (id, aggiornamenti, callback)

Questa funzione aggiorna un singolo documento identificato dal suo id. Per esempio,

Person.findByIdAndUpdate("507f1f77bcf86cd799439011", 
   {name: "James"}, 
   function(err, response){
      console.log(response);
   });

Creiamo un percorso per aggiornare le persone. Questa sarà una rotta PUT con l'id come parametro e dettagli nel payload.

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();
var mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

_.put('/people/:id', updatePerson);

function *updatePerson() {
   var self = this;
   yield Person.findByIdAndUpdate(self.params.id, 
      {$set: {self.request.body}}, function(err, response){
      
      if(err) {
         self.body = {
            message: "Error in updating person with id " + self.params.id};
      } else {
         self.body = response;
      }
   });
}

app.use(_.routes());
app.listen(3000);

Per testare questo percorso, inserisci quanto segue nel tuo terminale (sostituisci l'id con un id dalle persone create).

curl -X PUT --data "name = James&age = 20&nationality = American" https://localhost:3000/people/507f1f77bcf86cd799439011

Questo aggiornerà il documento associato all'id fornito nel percorso con i dettagli di cui sopra.

Eliminazione di documenti

Abbiamo coperto Create, Read e Update, ora vedremo come utilizzare mangusta per eliminare i documenti. Ci sono tre funzioni qui, esattamente come l'aggiornamento.

Model.remove (condition, [callback])

Questa funzione accetta un oggetto condizione come input e rimuove tutti i documenti che soddisfano le condizioni. Ad esempio, se dobbiamo rimuovere tutte le persone di 20 anni,

Person.remove({age:20});

Model.findOneAndRemove (condizione, [callback])

Questa funzione rimuove un file single, documento più rilevante in base alle condizioni oggetto. Per esempio,

Person.findOneAndRemove({name: "Ayush"});

Model.findByIdAndRemove (id, [callback])

Questa funzione rimuove un singolo documento identificato dal suo id. Per esempio,

Person.findByIdAndRemove("507f1f77bcf86cd799439011");

Ora creiamo un percorso per eliminare le persone dal nostro database.

var koa = require('koa');
var _ = require('koa-router')();
var app = koa();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

_.delete('/people/:id', deletePerson);
function *deletePerson(next){
   var self = this;
   yield Person.findByIdAndRemove(self.params.id, function(err, response){
      if(err) {
         self.body = {message: "Error in deleting record id " + self.params.id};
      } else {
         self.body = {message: "Person with id " + self.params.id + " removed."};
      }
   });
}

app.use(_.routes());
app.listen(3000);

Per testarlo, usa il seguente comando curl:

curl -X DELETE https://localhost:3000/people/507f1f77bcf86cd799439011

Questo rimuoverà la persona con l'id dato che produce il seguente messaggio. -

{message: "Person with id 507f1f77bcf86cd799439011 removed."}

Questo conclude come possiamo creare semplici applicazioni CRUD usando MongoDB, mongoose e Koa. Per esplorare ulteriormente la mangusta, leggi i documenti dell'API.