Koa.js - Banco de dados
Estamos recebendo as solicitações, mas não as armazenamos em nenhum lugar. Precisamos de um banco de dados para armazenar os dados. Usaremos um banco de dados NoSQL famoso chamadoMongoDB. Para instalar e ler sobre o Mongo, acesse este link.
Para usar o Mongo com Koa, precisamos de uma API cliente para o nó. Existem várias opções para nós, no entanto, para este tutorial, nos limitaremos ao mangusto . Mongoose é usado paradocument modelingno Node para MongoDB. Modelagem de documentos significa que vamos criar umModel (muito parecido com um class na programação orientada a documentos), e então iremos produzir documents usando este modelo (como criamos documents of a classem OOP). Todo o nosso processamento será feito nestes "documentos", então finalmente, iremos escrever estes documentos em nosso banco de dados.
Configurando o Mongoose
Agora que temos o Mongo instalado, vamos instalar o mongoose, da mesma forma que instalamos nossos outros pacotes de nós.
$ npm install --save mongooseAntes de começarmos a usar o mongoose, temos que criar um banco de dados usando o shell Mongo. Para criar um novo banco de dados, abra seu terminal e digite "mongo". Um shell Mongo será iniciado, digite o seguinte.
use my_dbUm novo banco de dados será criado para você. Sempre que você abrir o shell do Mongo, o padrão será "test" db e você terá que mudar para seu banco de dados usando o mesmo comando acima.
Para usar o mongoose, vamos solicitá-lo em nosso arquivo app.js e, em seguida, conectar ao serviço mongod em execução em 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);Agora que nosso aplicativo está conectado ao nosso banco de dados, vamos criar um novo modelo. Este modelo funcionará como uma coleção em nosso banco de dados. Para criar um novo modelo, use o seguinte código, antes de definir qualquer rota.
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);O código acima define o esquema para uma pessoa e é usado para criar um modelo de mangusto Person.
Salvando documentos
Agora vamos criar um novo formulário html, que vai pegar os detalhes de uma pessoa e salvá-lo em nosso banco de dados. Para criar o formulário, crie um novo arquivo de visualização denominado person.pug no diretório de visualizações com o seguinte conteúdo.
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 personAdicione também uma nova rota get em index.js para renderizar este 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);Vá para localhost: 3000 / person para verificar se nosso formulário está sendo exibido corretamente. Observe que isso é apenas a IU, ainda não está funcionando. Esta é a aparência do nosso formulário.
Agora definiremos um gerenciador de pós-rota em '/ pessoa' que tratará dessa solicitação.
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);No código acima, se recebermos algum campo vazio ou não recebermos nenhum campo, enviaremos uma resposta de erro. No entanto, se recebermos um documento bem formado, então criamos um documento newPerson a partir do modelo Person e o salvamos em nosso banco de dados usandonewPerson.save()função. Isso é definido no mangusto e aceita um retorno de chamada como argumento. Este retorno de chamada tem dois argumentos,error e response. Isso irá renderizar a visualização show_message, então precisamos criá-la também.
Para mostrar a resposta dessa rota, também precisaremos criar um show_messageVisão. Crie uma nova visualização com o código a seguir.
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!A seguir está a resposta que recebemos ao enviar o formulário com sucesso (show_message.pug).
Agora temos uma interface para criar pessoas!
Recuperando Documentos
O Mongoose fornece muitas funções para recuperar documentos, vamos nos concentrar em três delas. Todas essas funções também recebem um retorno de chamada como último parâmetro e, assim como a função salvar, seus argumentos são erro e resposta.
As três funções são -
Model.find (condições, retorno de chamada)
Esta função encontra todos os documentos correspondentes aos campos no objeto de condições. Os mesmos operadores usados no Mongo também funcionam no mangusto. Por exemplo, isso irá buscar todos os documentos da coleção das pessoas.
Person.find(function(err, response){
console.log(response);
});Isso irá buscar todos os documentos onde o nome do campo é "Ayush" e a idade é 20.
Person.find({name: "Ayush", age: 20},
function(err, response){
console.log(response);
});Também podemos fornecer a projeção de que precisamos, ou seja, os campos de que precisamos. Por exemplo, se quisermos apenas onames das pessoas cujo nationalityé "indiano" , usamos -
Person.find({nationality: "Indian"},
"name", function(err, response) {
console.log(response);
});Model.findOne (condições, retorno de chamada)
Essa função sempre busca um único documento mais relevante. Ele tem os mesmos argumentos exatos que Model.find ().
Model.findById (id, callback)
Esta função leva no _id(definido por mongo) como o primeiro argumento, uma string de projeção opcional e um retorno de chamada para lidar com a resposta. Por exemplo,
Person.findById("507f1f77bcf86cd799439011",
function(err, response){
console.log(response);
});Vamos criar uma rota para visualizar todos os registros de pessoas.
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);Atualizando Documentos
O Mongoose oferece três funções para atualizar documentos.
Model.update (condição, atualizações, retorno de chamada)
Essa função pega uma condição e atualiza o objeto como entrada e aplica as alterações a todos os documentos que correspondam às condições da coleção. Por exemplo, o código a seguir atualizará todos os documentos da pessoa para que tenham a nacionalidade "americana".
Person.update({age: 25},
{nationality: "American"},
function(err, response){
console.log(response);
});Model.findOneAndUpdate (condição, atualizações, retorno de chamada)
Ele faz exatamente o que é dito. Encontra um documento com base na consulta e o atualiza de acordo com o segundo argumento. Também leva um retorno de chamada como último argumento. Por exemplo,
Person.findOneAndUpdate({name: "Ayush"},
{age: 40},
function(err, response){
console.log(response);
});Model.findByIdAndUpdate (id, updates, callback)
Esta função atualiza um único documento identificado por seu id. Por exemplo,
Person.findByIdAndUpdate("507f1f77bcf86cd799439011",
{name: "James"},
function(err, response){
console.log(response);
});Vamos criar uma rota para atualizar as pessoas. Esta será uma rota PUT com o id como parâmetro e detalhes na carga útil.
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);Para testar esta rota, digite o seguinte em seu terminal (substitua o id por um id de seu povo criado).
curl -X PUT --data "name = James&age = 20&nationality = American" https://localhost:3000/people/507f1f77bcf86cd799439011Isso atualizará o documento associado ao id fornecido na rota com os detalhes acima.
Apagando Documentos
Nós cobrimos Create, Read e Update, agora veremos como o mongoose pode ser usado para excluir documentos. Existem três funções aqui, exatamente como atualizar.
Model.remove (condição, [retorno de chamada])
Esta função recebe um objeto de condição como entrada e remove todos os documentos que atendem às condições. Por exemplo, se precisarmos remover todas as pessoas com 20 anos,
Person.remove({age:20});Model.findOneAndRemove (condição, [retorno de chamada])
Esta função remove um single, documento mais relevante de acordo com o objeto de condições. Por exemplo,
Person.findOneAndRemove({name: "Ayush"});Model.findByIdAndRemove (id, [callback])
Esta função remove um único documento identificado por seu id. Por exemplo,
Person.findByIdAndRemove("507f1f77bcf86cd799439011");Agora vamos criar uma rota para deletar pessoas de nosso banco de dados.
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);Para testar isso, use o seguinte comando curl -
curl -X DELETE https://localhost:3000/people/507f1f77bcf86cd799439011Isso removerá a pessoa com o id fornecido, produzindo a seguinte mensagem. -
{message: "Person with id 507f1f77bcf86cd799439011 removed."}Isso conclui como podemos criar aplicativos CRUD simples usando MongoDB, mongoose e Koa. Para explorar mais o mangusto, leia os documentos da API.