Nesta postagem, mostraremos como usar o Mongoose para suas implantações do MongoDB para criar uma solução mais simples e baseada em esquema para modelar os dados do seu aplicativo.
O que é Mangusto?
Mongoose é uma “modelagem de objeto MongoDB elegante para Node.js “. Se você já usou o MongoDB antes e tentou operações básicas de banco de dados, deve ter notado que o MongoDB é "sem esquema". Quando você deseja implementar um banco de dados mais estruturado e deseja aproveitar o poder do MongoDB, o Mongoose é um dos ODM (O objeto D ata M aplicando) soluções.
Para demonstrar rapidamente, você executa um comando de inserção em uma coleção chamada users assim:
db.users.insert({ name : 'Arvind', gender : 'male'});
E logo depois disso, você pode executar:
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
e o MongoDB nunca reclamará da variação no número de colunas (pares chave-valor). Isso é muito flexível. Mas quando você deseja manter seus dados mais organizados e estruturados, você precisa manter isso no código do servidor, escrevendo a validação, certificando-se de que nada irrelevante seja armazenado em uma coleção. É aqui que o Mongoose facilita a vida.
"O Mongoose fornece uma solução direta e baseada em esquema para modelar seus dados de aplicativos e inclui conversão de tipos integrada, validação, criação de consultas, ganchos de lógica de negócios e muito mais , pronto para uso.”
Instalar Node.js e MongoDB
Para usar o Mongoose, precisamos ter o Node.js instalado. Você pode encontrar informações aqui.
Comece a desenvolver
Primeiro, vamos criar um pequeno playground onde possamos nos divertir. Crie uma nova pasta chamada myMongooseApp e abra o terminal/prompt aqui e execute:
npm init
Isso nos ajudará a inicializar um novo projeto de nó. Preencha-o conforme necessário. Em seguida, instalaremos o Mongoose como uma dependência do nosso projeto. Correr:
npm install mongoose --save-dev
Em seguida, inicie o serviço MongoDB executando:
mongod
Em seguida, crie um novo arquivo chamado index.js na raiz e abra-o em seu editor favorito. Adicione o código abaixo:
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/myTestDB');
var db = mongoose.connection;
db.on('error', function (err) {
console.log('connection error', err);
});
db.once('open', function () {
console.log('connected.');
});
Aqui, exigimos que o pacote Mongoose se conecte ao banco de dados e inicialize a conexão. O nome do nosso banco de dados é myTestDB.
Então corra:
node index.js
Agora você deve ver a mensagem conectada. Você também pode usar um pacote do nó chamado nodemon para reiniciar automaticamente o servidor do nó nas alterações.
Agora, nosso sandbox está pronto para ser usado!
Esquemas de mangusto
Esquemas são como esqueletos, o esqueleto de como sua coleta de dados ficará. Se você estiver lidando com uma coleção de usuários, seu esquema ficaria assim:
Name - String Age - Number Gender - String Date of Birth - Date
Se você estiver lidando com uma coleção de produtos, seu esquema será mais ou menos assim:
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Você pode ver o desvio. Quando nossos dados são protegidos com um esquema como esse, a possibilidade de armazenar dados de lixo diminui drasticamente.
Agora que entendemos os esquemas, vamos tentar construir um esquema de usuário usando o Mongoose. Volte para index.js e adicione o código abaixo:
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Encontre os campos básicos relacionados ao usuário e seus tipos de esquema aqui.
A seguir, criaremos um modelo a partir do esquema. Adicionar:
var User = mongoose.model('User', userSchema);
É isso aí, nosso modelo de usuário está pronto! Usaremos isso como nosso esquema básico para inserir usuários no banco de dados. Dessa forma, sabemos que cada documento em uma coleção de usuários terá os campos listados no esquema. Vamos criar uma nova instância de usuário e salvá-la no banco de dados. Adicionar:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
arvind.save(function (err, data) {
if (err) console.log(err);
else console.log('Saved : ', data );
});
Você deve ver algo assim:
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Sem aborrecimentos, sem problemas. API simples e fácil de interagir com modelos.
Digamos que queremos que cada modelo tenha um método chamado isYounger. Este método retornará true se a idade for menor que 50 e false se maior. Podemos fazer isso consultando o banco de dados para o usuário atual, verificando o condicionamento e retornando verdadeiro ou falso.
Mas e se quisermos implementar este método em todos os modelos de esquema de usuário? É assim que fazemos no Mongoose:
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/myTestDB');
var db = mongoose.connection;
db.on('error', function (err) {
console.log('connection error', err);
});
db.once('open', function () {
console.log('connected.');
});
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
userSchema.methods.isYounger = function () {
return this.model('User').age < 50 ? true : false;
}
var User = mongoose.model('User', userSchema);
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
arvind.save(function (err, data) {
if (err) console.log(err);
else console.log('Saved ', data );
});
console.log('isYounger : ',arvind.isYounger());
Na linha 21, adicionamos a definição do método e o resultado na linha 39 será false. Esta é uma maneira simples e prática de adicionar métodos ao seu esquema, tornando-o mais orientado a objetos.
Caso você tenha um campo de senha, você pode adicionar um método como encryptPassword(), para criptografar senha e comparePassword(), para comparar as senhas no login com o próprio userSchema. Você pode ler mais sobre autenticação de senha aqui.
O Mongoose pronto para uso também oferece algumas opções quando o esquema é criado. Por exemplo, se você der uma olhada na declaração de esquema abaixo, estamos passando uma opção strict:false:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
A opção estrita é verdadeira por padrão e não permite que os pares de valores-chave 'não esquema' sejam salvos. Por exemplo, isso será salvo:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Enquanto que:
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Todos os itens acima serão salvos menos o array bucketList porque não foi declarado como parte do esquema. Portanto, nenhum cliente que consumir seus serviços poderá despejar dados inválidos em suas coleções.
Outra opção legal é a coleção. Se você não quiser que o nome do seu modelo seja igual ao nome da coleção, você pode passar o nome como uma opção como:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Você pode encontrar uma lista de outras opções aqui.
Com o Mongoose, você também pode adicionar eventos aos seus esquemas como pré-salvar ou pós-salvar, onde você pode realizar validações, processar dados ou executar outras consultas nos respectivos eventos. Esses métodos são chamados de Middlewares.
Um exemplo simples pode ser um middleware paralelo como:
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
})
schema.pre('save', true, function (next, done) {
// calling next kicks off the next middleware in parallel
next();
doAsync(done);
});
Você pode ler mais sobre middlewares aqui. Em nosso próximo post, falaremos mais sobre como usar o Yeoman para gerar automaticamente scaffolding para seus projetos MongoDB.
Obrigado por ler. Comente.
@arvindr21
