Comment supprimer une base de données avec Mongoose?

Je prépare un script de création de base de données dans Node.js et Mongoose. Comment puis-je vérifier si la base de données existe déjà et si oui, la supprimer (la supprimer) à l'aide de Mongoose?

Je n'ai pas pu trouver un moyen de le laisser tomber avec Mongoose.

Il n'y a pas de méthode pour supprimer une collection de mangouste, le mieux que vous puissiez faire est d'en supprimer le contenu:

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

Mais il existe un moyen d'accéder au pilote javascript natif de mongodb, qui peut être utilisé pour cela

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

avertissement

Faites une sauvegarde avant d'essayer cela au cas où quelque chose ne va pas!

Mongoose créera une base de données s'il n'en existe pas déjà une lors de la connexion, donc une fois la connexion établie, vous pouvez simplement l'interroger pour voir s'il contient quelque chose.

Vous pouvez supprimer toute base de données à laquelle vous êtes connecté:

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

Si vous modifiez la solution de @ hellslam de cette manière, cela fonctionnera

J'utilise cette technique pour supprimer la base de données après mes tests d'intégration

//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 au moins ça l'a fait pour moi, alors j'ai décidé de partager =)

J'ai essayé les réponses de @ hellslam et @ silverfighter. J'ai trouvé une condition de course retenant mes tests. Dans mon cas, j'exécute des tests moka et dans la fonction avant du test, je veux effacer toute la base de données. Voici ce qui fonctionne pour moi.

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

Vous pouvez en savoir plus https://github.com/Automattic/mongoose/issues/1469

Une réponse mise à jour, pour 4.6.0+, si vous avez une préférence pour les promesses ( voir la documentation ):

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

J'ai testé ce code dans mon propre code, en utilisant mongoose 4.13.6. Notez également l'utilisation de l' useMongoClientoption ( voir la documentation ). Les documents indiquent:

La logique de connexion par défaut de Mongoose est obsolète à partir de la version 4.11.0. Veuillez activer la nouvelle logique de connexion à l'aide de l'option useMongoClient, mais assurez-vous de tester d'abord vos connexions si vous mettez à niveau une base de code existante!

La difficulté que j'ai rencontrée avec les autres solutions est qu'elles reposent sur le redémarrage de votre application si vous souhaitez que les index fonctionnent à nouveau.

Pour mes besoins (c'est-à-dire pouvoir exécuter un test unitaire sur toutes les collections d'armes nucléaires, puis les recréer avec leurs index), j'ai fini par implémenter cette solution:

Cela repose sur les bibliothèques underscore.js et async.js pour assembler les index en parallèle, cela pourrait être déroulé si vous êtes contre cette bibliothèque, mais je laisse cela comme un exercice pour le développeur.

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')
    })
  })
})

Pour vider une collection particulière dans une base de données:

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

Remarque:

1. Choisissez un modèle faisant référence à un schéma particulier (schéma de collection que vous souhaitez supprimer).
2. Cette opération ne supprimera pas le nom de la collection de la base de données.
3. Cela supprime tous les documents d'une collection.

Cela fonctionne pour moi à partir de Mongoose v4.7.0:

mongoose.connection.dropDatabase();

La meilleure façon de déposer votre base de données dans Mongoose dépend de la version de Mongoose que vous utilisez. Si vous utilisez une version de Mongoose que 4.6.4 ou plus récente, alors cette méthode ajoutée dans cette version fonctionnera probablement bien pour vous:

mongoose.connection.dropDatabase();

Dans les versions plus anciennes, cette méthode n'existait pas. Au lieu de cela, vous deviez utiliser un appel MongoDB direct:

mongoose.connection.db.dropDatabase();

Cependant, si cela était exécuté juste après la création de la connexion à la base de données, il pourrait éventuellement échouer silencieusement. Ceci est lié au fait que la connexion est réellement asynchrone et n'est pas encore configurée lorsque la commande se produit. Ce n'est normalement pas un problème pour les autres appels Mongoose comme .find(), quelle file d'attente jusqu'à ce que la connexion soit ouverte, puis exécutée.

Si vous regardez le code source du dropDatabase()raccourci qui a été ajouté, vous pouvez voir qu'il a été conçu pour résoudre exactement ce problème. Il vérifie si la connexion est ouverte et prête. Si tel est le cas, il déclenche la commande immédiatement. Sinon, il enregistre la commande à exécuter lorsque la connexion à la base de données est ouverte.

Certaines des suggestions ci-dessus recommandent de toujours placer votre dropDatabasecommande dans le opengestionnaire. Mais cela ne fonctionne que dans le cas où la connexion n'est pas encore ouverte.

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

Voici une version simple de la logique ci-dessus qui peut être utilisée avec les versions antérieures de 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();
});

Passer un rappel pour se connecter ne fonctionnera plus:

TypeError: impossible de lire la propriété '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()
    })
  })

Puisque la méthode remove est dépréciée dans la bibliothèque mangouste, nous pouvons utiliser la fonction deleteMany sans aucun paramètre passé.

Model.deleteMany();

Cela supprimera tout le contenu de ce modèle particulier et votre collection sera vide.

Pour déposer tous les documents d'une collection:

await mongoose.connection.db.dropDatabase();

Cette réponse est basée sur le fichier mongoose index.d.ts:

dropDatabase(): Promise<any>;

Pour déposer tous les documents d'une collection:

myMongooseModel.collection.drop();

comme vu dans les tests