Como eliminar um banco de dados com o Mongoose?

Estou preparando um script de criação de banco de dados em Node.js e Mongoose. Como posso verificar se o banco de dados já existe e, em caso afirmativo, descartá-lo (excluí-lo) usando o Mongoose?

Não consegui encontrar uma maneira de largá-lo com o Mongoose.

Não existe um método para retirar uma coleção do mangusto, o melhor que você pode fazer é remover o conteúdo de uma:

Model.remove({}, function(err) { 
   console.log('collection removed') 
});

Mas há uma maneira de acessar o driver javascript nativo mongodb, que pode ser usado para isso

mongoose.connection.collections['collectionName'].drop( function(err) {
    console.log('collection dropped');
});

Aviso

Faça um backup antes de tentar, caso algo dê errado!

O Mongoose criará um banco de dados, se ainda não houver um na conexão, portanto, depois de fazer a conexão, você pode apenas consultá-lo para ver se há algo nele.

Você pode descartar qualquer banco de dados ao qual esteja conectado:

var mongoose = require('mongoose');
/* Connect to the DB */
mongoose.connect('mongodb://localhost/mydatabase',function(){
    /* Drop the DB */
    mongoose.connection.db.dropDatabase();
});

Se você modificar a solução de @hellslam assim, ela funcionará

Eu uso esta técnica para descartar o banco de dados após meus testes de integração

//CoffeeScript
mongoose = require "mongoose"
conn = mongoose.connect("mongodb://localhost/mydb")

conn.connection.db.dropDatabase()

//JavaScript
var conn, mongoose;
mongoose = require("mongoose");
conn = mongoose.connect("mongodb://localhost/mydb");

conn.connection.db.dropDatabase();

HTH pelo menos funcionou para mim, então decidi compartilhar =)

Tentei as respostas de @hellslam e @ silverfighter. Encontrei uma condição de corrida impedindo meus testes. No meu caso estou executando testes mocha e na função before do teste quero apagar todo o banco de dados. Aqui está o que funciona para mim.

var con = mongoose.connect('mongodb://localhost/mydatabase');
mongoose.connection.on('open', function(){
    con.connection.db.dropDatabase(function(err, result){
        done();
    });
});

Você pode ler mais https://github.com/Automattic/mongoose/issues/1469

Uma resposta atualizada, para 4.6.0+, se você tiver uma preferência por promessas ( consulte os documentos ):

mongoose.connect('mongodb://localhost/mydb', { useMongoClient: true })
.then((connection) => {
   connection.db.dropDatabase();
   // alternatively:
   // mongoose.connection.db.dropDatabase();
});

Testei esse código em meu próprio código, usando o mongoose 4.13.6. Além disso, observe o uso da useMongoClientopção ( consulte os documentos ). Documentos indicam:

A lógica de conexão padrão do Mongoose está obsoleta a partir de 4.11.0. Aceite a nova lógica de conexão usando a opção useMongoClient, mas certifique-se de testar suas conexões primeiro se estiver atualizando uma base de código existente!

A dificuldade que tive com as outras soluções é que elas precisam reiniciar o aplicativo se você quiser que os índices funcionem novamente.

Para minhas necessidades (ou seja, ser capaz de executar um teste de unidade nos nukes de todas as coleções e, em seguida, recriá-los junto com seus índices), acabei implementando esta solução:

Isso se baseia nas bibliotecas underscore.js e async.js para montar os índices em paralelo, ele poderia ser desfeito se você for contra essa biblioteca, mas deixo isso como um exercício para o desenvolvedor.

mongoose.connection.db.executeDbCommand( {dropDatabase:1}, function(err, result) {
  var mongoPath = mongoose.connections[0].host + ':' + mongoose.connections[0].port + '/' + mongoose.connections[0].name
  //Kill the current connection, then re-establish it
  mongoose.connection.close()
  mongoose.connect('mongodb://' + mongoPath, function(err){
    var asyncFunctions = []

    //Loop through all the known schemas, and execute an ensureIndex to make sure we're clean
    _.each(mongoose.connections[0].base.modelSchemas, function(schema, key) {
      asyncFunctions.push(function(cb){
        mongoose.model(key, schema).ensureIndexes(function(){
          return cb()
        })
      })
    })

    async.parallel(asyncFunctions, function(err) {
      console.log('Done dumping all collections and recreating indexes')
    })
  })
})

Para esvaziar uma coleção específica em um banco de dados:

model.remove(function(err, p){
    if(err){ 
        throw err;
    } else{
        console.log('No Of Documents deleted:' + p);
    }
});

Nota:

1. Escolha um modelo que se refira a um esquema específico (esquema de coleção que você deseja excluir).
2. Esta operação não excluirá o nome da coleção do banco de dados.
3. Isso exclui todos os documentos de uma coleção.

Isso funciona para mim a partir do Mongoose v4.7.0:

mongoose.connection.dropDatabase();

A melhor maneira de eliminar seu banco de dados no Mongoose depende de qual versão do Mongoose você está usando. Se você estiver usando uma versão do Mongoose 4.6.4 ou mais recente, este método adicionado nessa versão provavelmente funcionará bem para você:

mongoose.connection.dropDatabase();

Em versões mais antigas, esse método não existia. Em vez disso, você deveria usar uma chamada direta do MongoDB:

mongoose.connection.db.dropDatabase();

No entanto, se for executado logo após a criação da conexão com o banco de dados, pode ocorrer uma falha silenciosa. Isso está relacionado ao fato de a conexão ser realmente assíncrona e não ter sido configurada ainda quando o comando ocorrer. Normalmente, isso não é um problema para outras chamadas do Mongoose, como .find(), que ficam na fila até que a conexão seja aberta e depois executada.

Se você olhar o código-fonte do dropDatabase()atalho que foi adicionado, verá que ele foi projetado para resolver exatamente esse problema. Ele verifica se a conexão está aberta e pronta. Nesse caso, ele dispara o comando imediatamente. Caso contrário, ele registra o comando a ser executado quando a conexão com o banco de dados for aberta.

Algumas das sugestões acima recomendam sempre colocar seu dropDatabasecomando no openmanipulador. Mas isso só funciona no caso em que a conexão ainda não está aberta.

Connection.prototype.dropDatabase = function(callback) {
  var Promise = PromiseProvider.get();
  var _this = this;
  var promise = new Promise.ES6(function(resolve, reject) {
    if (_this.readyState !== STATES.connected) {
      _this.on('open', function() {
        _this.db.dropDatabase(function(error) {
          if (error) {
            reject(error);
          } else {
            resolve();
          }
        });
      });
    } else {
      _this.db.dropDatabase(function(error) {
        if (error) {
          reject(error);
        } else {
          resolve();
        }
      });
    }
  });
  if (callback) {
    promise.then(function() { callback(); }, callback);
  }
  return promise;
};

Esta é uma versão simples da lógica acima que pode ser usada com versões anteriores do Mongoose:

// This shim is backported from Mongoose 4.6.4 to reliably drop a database
// http://stackoverflow.com/a/42860208/254318
// The first arg should be "mongoose.connection"
function dropDatabase (connection, callback) {
    // readyState 1 === 'connected'
    if (connection.readyState !== 1) {
      connection.on('open', function() {
        connection.db.dropDatabase(callback);
      });
    } else {
      connection.db.dropDatabase(callback);
    }
}  

Mongoose 4.6.0+:

mongoose.connect('mongodb://localhost/mydb')
mongoose.connection.once('connected', () => {
    mongoose.connection.db.dropDatabase();
});

Passar uma chamada de retorno para se conectar não funcionará mais:

TypeError: Não é possível ler a propriedade 'commandsTakeWriteConcern' de null

beforeEach((done) => {
      mongoose.connection.dropCollection('products',(error ,result) => {
      if (error) {
        console.log('Products Collection is not dropped')
      } else {
        console.log(result)
      }
    done()
    })
  })

Como o método remove é depreciado na biblioteca mongoose, podemos usar a função deleteMany sem parâmetros passados.

Model.deleteMany();

Isso excluirá todo o conteúdo deste modelo específico e sua coleção ficará vazia.

Para soltar todos os documentos em uma coleção:

await mongoose.connection.db.dropDatabase();

Esta resposta é baseada no arquivo mongoose index.d.ts:

dropDatabase(): Promise<any>;

Para descartar todos os documentos em uma coleção:

myMongooseModel.collection.drop();

como visto nos testes