Neste tutorial vou mostrar como interagir com uma base de dados MongoDB com Node.js.
Vamos usar o pacote mongoosejs. Se você já tem um projeto Node.js no qual você está trabalhando, instale-o usando:
$ npm install mongoose
Se você estiver começando do zero, você pode dar uma olhada no minha introdução sobre Node.js ou comece criando uma nova pasta, e com seu terminal dentro da pasta, execute o comando npm init -y para iniciar um novo projeto Node.js, e então execute o comando npm install mongoose.
Crie um novo arquivo server.js. Você primeiro vai precisar do pacote mongoose no seu projeto.
const mongoose = require('mongoose');
Crie um URL para o servidor MongoDB. Se você estiver usando MongoDB localmente, a URL será algo como mongodb://localhost:27017, 27017 é a porta padrão do MongoDB. E crie uma outra variável com o nome do seu banco de dados.
O pacote vem com um método chamado connect() que vai nos ajudar na conexão com MongoDB. Vamos usar esse método para criar uma instância do banco de dados.
const mongoose = require('mongoose');
const server = 'mongodb://localhost:27017'
const database = 'myDatabase';
mongoose.connect(`${server}/${database}`,
{ useNewUrlParser: true, useUnifiedTopology: true }
);
O pacote Mongoose tem algumas depreciações no projeto, devido a mudanças no MongoDB, por isso precisamos usar as flags {useNewUrlParser: true, useUnifiedTopology: true }, se quiser ver mais detalhes, basta clicar aqui.
Podemos então testar se a conexão foi bem sucedida ou não.
const mongoose = require('mongoose');
const server = 'mongodb://localhost:27017'
const database = 'myDatabase';
mongoose.connect(`${server}/${database}`,
{ useNewUrlParser: true, useUnifiedTopology: true }
).then(() => {
console.log("Successfully connect to MongoDB.");
})
.catch(err => {
console.error("Connection error", err);
process.exit();
});
No terminal, rode o comando node server.js. Você dever ver essa mensagem no seu terminal:
Successfully connect to MongoDB.
Tudo em mongoose começa com um Schema. Cada esquema mapeia para uma coleção. Coleções são uma das estruturas básicas do MongoDB. MongoDB define a forma dos documentos dentro dessa coleção.
const Schema = mongoose.Schema;
const UserSchema = new Schema({
name: String
});
Uma instância de um model é chamado de documento. Vamos então utilizar o nosso método model() para criar nosso documento.
const User = mongoose.model('User', UserSchema);
O primeiro argumento é o nome singular da coleção para a qual seu modelo está destinado. O segundo argumento, é o objeto Schema da nossa coleção que definimos antes, UserSchema.
Mongoose vai procurar automaticamente a versão plural, em letras minúsculas, do nome do seu modelo.
Com o nosso documento User criado, salvar os dados no banco de dados é simples. Vamos criar uma nova instância do documento e passar os dados que queremos inserir, no nosso exemplo, o nosso model aceita apenas o atributo name. Podemos então utilizar o método save() diretamente no nosso model para persistir os dados.
const user = new User({ name: 'John' });
user.save()
.then(() => console.log('User Created'))
.catch(() => console.log('User model Error'))
Você pode testar usando o comando, node server.js no seu terminal. Você deve ver essa mensagem.
Successfully connect to MongoDB. User Created
Você pode adicionar vários itens usando o método create(), passando um Array como primeiro parâmetro. Esse método executa o método save() para cada item do Array.
const userArray = [{ name: 'Alice' }, { name: 'Paul' }]
User.create(userArray)
.then(() => console.log('User Created'))
.catch(() => console.log('User model Error'))
Mongoose tem um método muito simples pra resolver isso. Com o método find() sendo chamado no seu modelo, você consegue recuperar todos os documentos da sua coleção.
User.find()
.then(users => { console.log(users) })
.catch(error => { console.log("User Find Error", error) })
O seu resultado no terminal após rodar o comando node server.js deve ser algo assim:
Successfully connect to MongoDB.
[ { _id: '5f05a2b58415d87a550de613', name: 'Alice', __v: 0 },
{ _id: '5f05a2b58415d87a550de614', name: 'Paul', __v: 0 },
{ _id: '5f05a4c99f222e7e9c96d825', name: 'John', __v: 0 } ]
Você consegue filtrar os documentos passando a lista de parâmetros dentro do método find(). Esse processo é parecido com o WHERE do SQL.
Como temos apenas um atributo nos nossos documentos, vamos filtrar pelo nome de cada usuário.
User.find({ name: 'John' })
.then(user => { console.log(user); })
.catch(error => { console.log("User Find Error", error) })
E o seu resultado deve ser esse:
Successfully connect to MongoDB.
[ { _id: '5f05a4c99f222e7e9c96d825', name: 'John', __v: 0 } ]
Se você precisar encontrar mais de um documento você pode usar o operador $in.
User.find({ name: { $in: ['John', 'Paul'] } })
.then(users => { console.log(users); })
.catch(error => { console.log("User Find Error", error) })
Successfully connect to MongoDB.
[ { _id: '5f05a2b58415d87a550de614', name: 'Paul', __v: 0 },
{ _id: '5f05a4c99f222e7e9c96d825', name: 'John', __v: 0 } ]
Abaixo está um exemplo de como usar save() para atualizar o nome do usuário.
async function update(name, newName) {
try {
const user = await User.findOne({ name: name });
if (user) {
user.name = newName;
await user.save();
console.log('User Updated');
}
console.log('User not Found!');
return;
} catch (error) {
console.log('Update Error', error);
return;
}
}
update('Paul', 'Peter');
Este simples exemplo tem algumas nuances. Primeiro, o método save() é um método de um documento, o que significa que você deve ter um documento para utiliza-lo. Você precisa usar o método create() ou usar find() para obter um documento.
Estou utilizando o método findOne() por que ele retorna apenas um documento, o método find() retorna um Array, mesmo que encontre apenas uma correspondência.
Em segundo lugar, os documentos têm rastreamento de mudanças. Quando você chama doc.save(), Mongoose sabe que você alterou a propriedade name e transforma sua chamada save() em updateOne({ $set: { name } }).
Se prefere usar Promises, você pode eliminar o uso da função, fazendo assim:
User.findOne({ name: "Paul" })
.then(user => {
if (user) {
user.name = 'Peter';
user.save();
console.log('User Updated');
}
console.log('User not Found!');
})
.catch(error => {
console.log('Update Error', error);
})
O método que vamos usar é o deleteOne(), esta método chama a função Collection#deleteOne() do MongoDB Driver. A promise devolvida resolve para um objeto que contém 3 propriedades:
User.deleteOne({ name: 'John' })
.then(response => { console.log(response) })
.catch(error => { console.log('Delete Error', error); })
O resultado desse nosso exemplo no terminal:
{ n: 1, ok: 1, deletedCount: 1 }
Uma vez terminadas as operações, podemos chamar o método de close():
mongoose.connection.close();
Se gostou desse artigo, não deixe de se inscrever na newsletter e fique informado sempre que tiver conteúdo novo!
E se ainda ficou alguma dúvida, ou se você tiver alguma sugestão, você pode deixar o seu comentário logo aqui em abaixo! Até a próxima.
Deixe um comentário