Koa.js - Datenbank

Wir erhalten die Anfragen, speichern sie jedoch nirgendwo. Wir benötigen eine Datenbank, um die Daten zu speichern. Wir werden eine berühmte NoSQL-Datenbank namens verwendenMongoDB. Um Mongo zu installieren und zu lesen, gehen Sie zu diesem Link.

Um Mongo mit Koa verwenden zu können, benötigen wir eine Client-API für den Knoten. Es gibt mehrere Möglichkeiten für uns, aber für dieses Tutorial bleiben wir bei Mungo . Mungo wird verwendet fürdocument modelingim Knoten für MongoDB. Dokumentmodellierung bedeutet, dass wir eine erstellenModel (ähnlich wie ein class in dokumentenorientierter Programmierung), und dann werden wir produzieren documents mit diesem Modell (wie wir erstellen documents of a classin OOP). Alle unsere Verarbeitung wird auf diesen "Dokumenten" durchgeführt, und schließlich werden wir diese Dokumente in unsere Datenbank schreiben.

Mungo einrichten

Nachdem wir Mongo installiert haben, lassen Sie uns Mungo installieren, genauso wie wir unsere anderen Knotenpakete installiert haben.

$ npm install --save mongoose

Bevor wir Mungo verwenden, müssen wir eine Datenbank mit der Mongo-Shell erstellen. Um eine neue Datenbank zu erstellen, öffnen Sie Ihr Terminal und geben Sie "mongo" ein. Eine Mongo-Shell wird gestartet. Geben Sie Folgendes ein.

use my_db

Eine neue Datenbank wird für Sie erstellt. Wenn Sie die Mongo-Shell öffnen, wird die Datenbank standardmäßig "getestet", und Sie müssen mit demselben Befehl wie oben zu Ihrer Datenbank wechseln.

Um Mungo verwenden zu können, benötigen wir es in unserer Datei app.js und stellen dann eine Verbindung zum Mongod-Dienst her, der auf mongodb: // localhost ausgeführt wird

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);

Jetzt ist unsere App mit unserer Datenbank verbunden. Erstellen wir ein neues Modell. Dieses Modell dient als Sammlung in unserer Datenbank. Verwenden Sie zum Erstellen eines neuen Modells den folgenden Code, bevor Sie Routen definieren.

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);

Der obige Code definiert das Schema für eine Person und wird zum Erstellen eines Mungomodells verwendet Person.

Dokumente speichern

Jetzt erstellen wir ein neues HTML-Formular, das die Details einer Person abruft und in unserer Datenbank speichert. Erstellen Sie zum Erstellen des Formulars eine neue Ansichtsdatei mit dem Namen person.pug im Ansichtsverzeichnis mit dem folgenden Inhalt.

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

Fügen Sie außerdem eine neue get-Route in index.js hinzu, um dieses Dokument zu rendern.

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);

Gehen Sie zu localhost: 3000 / Person, um zu überprüfen, ob unser Formular richtig angezeigt wird. Beachten Sie, dass dies nur die Benutzeroberfläche ist und noch nicht funktioniert. So sieht unser Formular aus.

Wir definieren nun unter '/ person' einen Post-Route-Handler, der diese Anfrage bearbeitet.

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);

Wenn wir im obigen Code ein leeres Feld erhalten oder kein Feld erhalten, senden wir eine Fehlerantwort. Wenn wir jedoch ein wohlgeformtes Dokument erhalten, erstellen wir ein neues Personendokument aus dem Personenmodell und speichern es mit in unserer DatenbanknewPerson.save()Funktion. Dies ist in Mungo definiert und akzeptiert einen Rückruf als Argument. Dieser Rückruf hat zwei Argumente:error und response. Dadurch wird die Ansicht show_message gerendert, daher müssen wir diese ebenfalls erstellen.

Um die Antwort von dieser Route anzuzeigen, müssen wir auch eine erstellen show_messageAussicht. Erstellen Sie eine neue Ansicht mit dem folgenden Code.

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!

Im Folgenden finden Sie die Antwort, die wir nach erfolgreichem Absenden des Formulars erhalten (show_message.pug).

Wir haben jetzt eine Schnittstelle, um Personen zu erstellen!

Dokumente abrufen

Mungo bietet viele Funktionen zum Abrufen von Dokumenten, wir werden uns auf drei davon konzentrieren. Alle diese Funktionen verwenden auch einen Rückruf als letzten Parameter, und genau wie die Speicherfunktion sind ihre Argumente Fehler und Antwort.

Die drei Funktionen sind -

Model.find (Bedingungen, Rückruf)

Diese Funktion findet alle Dokumente, die mit den Feldern im Bedingungsobjekt übereinstimmen. Dieselben in Mongo verwendeten Operatoren arbeiten auch in Mungos. Dadurch werden beispielsweise alle Dokumente aus der Personensammlung abgerufen.

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

Dadurch werden alle Dokumente abgerufen, bei denen der Feldname "Ayush" und das Alter 20 Jahre beträgt.

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

Wir können auch die Projektion bereitstellen, die wir benötigen, dh die Felder, die wir benötigen. Zum Beispiel, wenn wir nur die wollennames der Menschen, deren nationalityist "indisch" , wir benutzen -

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

Model.findOne (Bedingungen, Rückruf)

Diese Funktion ruft immer ein einzelnes, relevantestes Dokument ab. Es hat genau die gleichen Argumente wie Model.find ().

Model.findById (ID, Rückruf)

Diese Funktion übernimmt die _id(definiert von mongo) als erstes Argument, eine optionale Projektionszeichenfolge und ein Rückruf zur Verarbeitung der Antwort. Zum Beispiel,

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

Erstellen wir eine Route, um alle Personendatensätze anzuzeigen.

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);

Dokumente aktualisieren

Mongoose bietet drei Funktionen zum Aktualisieren von Dokumenten.

Model.update (Zustand, Updates, Rückruf)

Diese Funktion übernimmt eine Bedingung und aktualisiert das Objekt als Eingabe und wendet die Änderungen auf alle Dokumente an, die den Bedingungen in der Sammlung entsprechen. Mit dem folgenden Code werden beispielsweise alle Personendokumente aktualisiert, um die Nationalität "Amerikaner" zu erhalten.

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

Model.findOneAndUpdate (Bedingung, Aktualisierungen, Rückruf)

Es macht genau das, was gesagt wird. Findet ein Dokument basierend auf der Abfrage und aktualisiert es gemäß dem zweiten Argument. Als letztes Argument wird auch ein Rückruf verwendet. Zum Beispiel,

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

Model.findByIdAndUpdate (ID, Updates, Rückruf)

Diese Funktion aktualisiert ein einzelnes Dokument, das durch seine ID identifiziert wird. Zum Beispiel,

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

Lassen Sie uns eine Route erstellen, um Personen zu aktualisieren. Dies ist eine PUT-Route mit der ID als Parameter und Details in der Nutzlast.

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);

Geben Sie zum Testen dieser Route Folgendes in Ihr Terminal ein (ersetzen Sie die ID durch eine ID Ihrer erstellten Personen).

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

Dadurch wird das Dokument, das der in der Route angegebenen ID zugeordnet ist, mit den oben genannten Details aktualisiert.

Dokumente löschen

Wir haben abgedeckt Create, Read und Update, jetzt werden wir sehen, wie Mungo zum Löschen von Dokumenten verwendet werden kann. Hier gibt es drei Funktionen, genau wie beim Update.

Model.remove (Bedingung, [Rückruf])

Diese Funktion verwendet ein Bedingungsobjekt als Eingabe und entfernt alle Dokumente, die den Bedingungen entsprechen. Wenn wir zum Beispiel alle Personen im Alter von 20 Jahren entfernen müssen,

Person.remove({age:20});

Model.findOneAndRemove (Bedingung, [Rückruf])

Diese Funktion entfernt a single, relevantestes Dokument nach Bedingungsobjekt. Zum Beispiel,

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

Model.findByIdAndRemove (id, [Rückruf])

Diese Funktion entfernt ein einzelnes Dokument, das durch seine ID identifiziert wird. Zum Beispiel,

Person.findByIdAndRemove("507f1f77bcf86cd799439011");

Erstellen wir nun eine Route, um Personen aus unserer Datenbank zu löschen.

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);

Verwenden Sie zum Testen den folgenden Curl-Befehl:

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

Dadurch wird die Person mit der angegebenen ID entfernt, die die folgende Nachricht erstellt. - -

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

Dies fasst zusammen, wie wir einfache CRUD-Anwendungen mit MongoDB, Mungo und Koa erstellen können. Lesen Sie die API-Dokumente, um Mungo weiter zu erkunden .