Mongoose: DeprecationWarning : `open()` est obsolète dans mongoose >= 4.11.0, utilisez plutôt `openUri()`

+1 , je ne sais pas où corriger pour se débarrasser de cet avertissement

L'avertissement concerne en fait un code à l'intérieur de Mongoose, lorsque la chaîne de connexion a un jeu de réplicas :

Mongoose.prototype.connect = function() {
  var conn = this.connection;
  if ((arguments.length === 2 || arguments.length === 3) &&
      typeof arguments[0] === 'string' &&
      typeof arguments[1] === 'object' &&
      arguments[1].useMongoClient === true) {
    return conn.openUri(arguments[0], arguments[1], arguments[2]);
  }
  if (rgxReplSet.test(arguments[0]) || checkReplicaSetInUri(arguments[0])) {
    return new MongooseThenable(this, conn.openSet.apply(conn, arguments));
  }

  return new MongooseThenable(this, conn.open.apply(conn, arguments));
};

@tinovyatkin

Alors, c'est un bug ?

ressemble à un bogue, pouvons-nous contourner le problème en ajoutant useMongoClient: true aux options (vous pouvez alors voir une dépréciation du pilote MongoDB, mais cela ne se produit pas)

L'ajout useMongoClient: true fait disparaître le message, mais mes documents cessent tout simplement de se charger. Je ne l'ai pas débogué plus en profondeur, mais je préférerais entendre les meilleures pratiques avant d'adapter mon code.

Mon application ne fonctionne pas non plus avec la solution de contournement suggérée ci-dessus. Il n'exécute tout simplement plus la méthode MyModel.find et ne donne aucune erreur ni délai d'attente.

La raison pour laquelle l'option "useMongoclient: true" ne fonctionne pas dans la plupart des cas est que pour cette option, chaque objet lié à la connexion mongoose renvoie un objet factice car il ne peut pas accéder à mongodb

J'ai essayé de l'utiliser comme

const server = express();
mongoose.connect('mongodb://localhost/advisorDemoTestDB', { useMongoClient: true })
    .then(() => require('./db-init')(server))
    .catch(err => console.error(err));

mais ça ne marche pas

Ayant le même problème, même sans jeux de répliques.

Ayant le même problème :

(node:4138) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0,
 use `openUri()` instead, or set the `useMongoClient` option if using `connect()` 
or `createConnection()`

Même...

Après avoir ajouté le code ci-dessous à ma connexion mongo, je ne peux plus rien interroger maintenant.
{useMongoClient : vrai}.
Toutes les suggestions seront appréciées !!

+1 identique avec les jeux de répliques, pas de partitionnement

+1

+1

+1

+1

+1

+1

+1

La solution la plus simple pour cela; " npm remove mongoose " puis " npm install [email protected] --save " problème résolu. La mise à niveau n'est pas toujours la meilleure option.

+1

+1

Je reçois 2 messages :

(node:9260) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0,
use `openUri()` instead, or set the `useMongoClient` option if using `connect()`
or `createConnection()`

Server started on port 3000

Db.prototype.authenticate method will no longer be available in the next major
release 3.x as MongoDB 3.6 will only allow auth against users in the admin db
and will no longer allow multiple credentials on a socket. Please authenticate
using MongoClient.connect with auth credentials.

La première erreur est apparue dans 4.11.0. La deuxième erreur est également apparue dans la version précédente de Mongoose.

plhosk, le second aurait dû être corrigé en 4.11 mais il semble qu'il soit toujours là, pour moi aussi.

+1

+1 malheureusement.

Installé 4.10.8 sans problèmes. Veuillez envisager de remplacer npm install mongoose --save par défaut par 4.10.8 jusqu'à ce que 11 soit stable.

+1

+1

+1

+1

J'ai aussi trouvé ce problème aussi.
__Version du nœud__ : v6.10.0

__MongoDB__ emvironment : (j'ai couru sur la dernière version du conteneur Docker Mongo)

2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] db version v3.4.5
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] git version: 520b8f3092c48d934f0cd78ab5f40fe594f96863
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] OpenSSL version: OpenSSL 1.0.1t  3 May 2016
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] allocator: tcmalloc
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] modules: none
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] build environment:
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     distmod: debian81
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     distarch: x86_64
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     target_arch: x86_64
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] options: { security: { authorization: "enabled" } }

Ma configuration de connexion :

var dbURL = `mongodb://${dbHost}:${dbPort}/${dbName}?authSource=admin`;
var dbAuth = { 
    useMongoClient: false
    user: dbUser,
    pass: dbPass
}
mongoose.connect(dbURL, dbAuth);

Quand j'utilise useMongoClient pour être faux. Mongoose affiche les avertissements suivants :

(node:7868) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, or set the `useMongoClient` option if using `connect()` or `createConnection()`
Express server listening on port 3222 in development mode
Db.prototype.authenticate method will no longer be available in the next major release 3.x as MongoDB 3.6 will only allow auth against users in the admin db and will no longer allow multiple credentials on a socket. Please authenticate u
sing MongoClient.connect with auth credentials.

Mais ça marche très bien.

Cependant, lorsque je l'ai défini sur true , j'ai trouvé cette erreur :

Unhandled rejection MongoError: not authorized on users to execute command { listIndexes: "sessions", cursor: {} }
    at Function.MongoError.create (<my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\error.js:31:11)
    at queryCallback (<my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\cursor.js:212:36)
    at <my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\connection\pool.js:469:18
    at _combinedTickCallback (internal/process/next_tick.js:67:7)
    at process._tickCallback (internal/process/next_tick.js:98:9)

J'essaie également de supprimer authSource=admin de l'URL de connexion, mais cela ne fonctionne toujours pas

(nœud : 451) DeprecationWarning : open() est obsolète dans mongoose >= 4.11.0, utilisez
openUri() la place, ou définissez l'option useMongoClient si vous utilisez connect() ou createConnection()
La méthode Db.prototype.authenticate ne sera plus disponible dans la prochaine
bail 3.x car MongoDB 3.6 n'autorisera l'authentification que contre les utilisateurs dans la base de données d'administration et w
ill n'autorise plus plusieurs informations d'identification sur un socket. Veuillez vous authentifier en utilisant M
ongoClient.connect avec les identifiants d'authentification.

Je reçois ce problème avec la version 4.11.0 de Mongoose et la version 3.4.5 de MongoDB

+1

+1

Utiliser

mongoose.createConnection(URI)

@nandofalcao Lors de l'utilisation :

• mongoose.createConnection (URI);
• mongoose.connect (URI, {useMongoClient : true} );

Apparemment, je ne peux pas enregistrer de nouveaux enregistrements.

let userSchema = mongoose.Schema({ name: String });
let User = mongoose.model('User', userSchema);
let joao = new User({ name: 'NewJoao ' });
joao.save((err) => err ? throw err : console.log('User created!'));//nothing happens

Ajout de polyglotte ce soir et +1 en faisant l'expérience.

// Load Mongoose
const mongoose = require('mongoose');
// import mongoose from 'mongoose' didn't give access to .connect()

// Use native Promises
mongoose.Promise = global.Promise;

// Connect database
export const Mongoose = new Promise((resolve, reject) => {
  const uri = `mongodb://${Singleton.currentConfig.databases.mongodb.host}/${Singleton.currentConfig.databases.mongodb.database}`;

  const options = {
    user: Singleton.currentConfig.databases.mongodb.user,
    pass: Singleton.currentConfig.databases.mongodb.password,
    server: {
      reconnectTries: Singleton.currentConfig.databases.mongodb.reconnectTries,
      reconnectInterval: Singleton.currentConfig.databases.mongodb.reconnectInterval,
      socketOptions: {
        keepAlive: Singleton.currentConfig.databases.mongodb.keepAlive,
        connectTimeoutMS: Singleton.currentConfig.databases.mongodb.connectTimeoutMS
      },
    },
  };

  // Initiate document store
  mongoose.connect(uri, options)

  // Check for anomalies
  .then((connected) => {
    if (mongoose.connection.readyState !== 1) {
      reject(connected);
    }
    resolve(connected);
  })

  // Complete meltdown
  .catch((error) => {
    console.log(`MongoDB Connection Error: ${error}`);
    process.exit(0);
  });
});

+1

et j'ai le 2ème message :

[2017-06-27 16:14:23.702] [INFO] :: - Le serveur a démarré sur le port 2000

(node:1193) DeprecationWarning : open() est obsolète dans mongoose >= 4.11.0, utilisez openUri() la place, ou définissez l'option useMongoClient si vous utilisez connect() ou createConnection()

La méthode Db.prototype.authenticate ne sera plus disponible dans la prochaine version majeure 3.x car MongoDB 3.6 n'autorisera l'authentification que contre les utilisateurs dans la base de données d'administration et n'autorisera plus plusieurs informations d'identification sur un socket. Veuillez vous authentifier à l'aide de MongoClient.connect avec les informations d'identification d'authentification.

+1

+1

+1

+1

+1

Quelqu'un peut-il le verrouiller pour éviter les +1 inutiles ?

Par courtoisie envers les abonnés de ce fil, veuillez cesser de répondre avec +1 car cela génère des notifications par e-mail inutiles. Ceci n'est pas un forum. Si vous souhaitez suivre ce fil, utilisez le bouton d' abonnement dans la barre latérale droite. Vous pouvez également faire des recherches vous-même et apporter des solutions.

J'ai changé la version en 4.10.8 et ça marche bien maintenant.

On dirait que ValYouW a une solution potentielle au problème de chargement de document ici : #5404

mongoose.connection.openUri('mongodb://127.0.0.1/camp_v12')

quelqu'un a-t-il essayé cela? mon avertissement obsolète a disparu lorsque j'utilise ceci, il provenait de la documentation

http://mongoosejs.com/docs/connections.html

@crisamdegracia qui suppose que vous avez déjà une connexion

// Or, if you already have a connection
connection.openUri('mongodb://localhost/myapp', { /* options */ });

ce que nous ne faisons pas (au moins moi depuis que je me connectais à mongodb en utilisant la méthode mongoose.connect)

mongoose.connect(config.get('mongo'), {
  useMongoClient: true,
});

Je n'ai trouvé aucun document... Qu'est-ce qui ne va pas ?

+1

Ainsi, après avoir examiné le problème lié de @ phased90 qui explique que vous pouvez vous connecter comme suit :

const mongoose = require('mongoose');

mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost/test', {useMongoClient: true})
    .then(() => {
        let Cat = mongoose.model('Cat', {name: String});
        let kitty = new Cat({name: 'Zildjian'});

        kitty.save(err => {
            if (err) {
                console.log(err);
            } else {
                console.log('meow');
            }
        });
    })
    .catch(err => console.error(err));

J'ai fait une plongée rapide dans le code et il semble que 4.11 renvoie MongooseThenable sauf lorsque l'option {useMongoClient: true} est fournie. Dans cette instance, il appelle Connection.prototype.openUri qui renvoie une nouvelle instance de Promise.ES6 . Cet appel Connection.prototype.openUri devrait-il être enveloppé dans un MongooseThenable ?

Mes excuses pour la question, c'est la première fois que je regarde cette base de code, donc je suis un peu incertain. Mais je serais heureux d'essayer d'aider à fournir un correctif si je peux obtenir des éclaircissements sur le fait que Moongoose.prototype.connect devrait toujours renvoyer une instance de MongooseThenable .

Sachez que l'utilisation {useMongoClient: true} entraînera l'appel Connection.prototype.openUri , ce qui ne déclenchera pas les commandes mises en mémoire tampon qui ont été créées __avant__ la connexion à une base de données en raison de #5404

+1

Désolé, les choses ont été folles, je vais y jeter un œil dans un instant.

@varunjayaraman pas besoin d'être désolé mon pote. Les gens peuvent soit attendre, soit essayer de le réparer par eux-mêmes.

+1

Donc, en ce qui concerne le problème réel qui a été ouvert, l'avertissement de dépréciation n'est pas un bogue, c'est juste un avertissement : mongoose va déprécier sa logique de connexion actuelle, vous devez donc transmettre le useMongoClient . Cela se trouve dans la documentation

Sur une note séparée, il semble qu'il s'agissait d'un changement de rupture vers l'arrière, j'espère que cela pourra être corrigé dans la prochaine version mineure (ou peut-être que ce n'est pas le cas, je fonctionne avec très peu de sommeil ici):

cela fonctionnerait normalement (sauf pour la partie useMongoClient , qui est nouvelle):

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5399`


exec()
  .then(() => {
    console.log('successfully ran program');
    process.exit(0);
  })
  .catch(error => {
    console.error(`Error: ${ error }\n${ error.stack }`);
  });


function exec() {
  return co(function*() {
    const db = mongoose.createConnection(`mongodb://localhost:27017/${ GITHUB_ISSUE }`, { useMongoClient: true })
    const schema = new mongoose.Schema({
      name: String
    });


    const Model = db.model('Model', schema);
  });
}

Cela semble me lancer une erreur car db.model n'est plus une fonction.

Lorsque vous utilisez mongoose.model , cela fonctionne :

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5399`


exec()
  .then(() => {
    console.log('successfully ran program');
    process.exit(0);
  })
  .catch(error => {
    console.error(`Error: ${error}\n${error.stack}`);
  });


function exec() {
  return co(function* () {
    const db = mongoose.connect(`mongodb://localhost:27017/${GITHUB_ISSUE}`, { useMongoClient: true })

    return db
      .then(() => {
        const schema = new mongoose.Schema({
          name: String
        });


        const Model = mongoose.model('Model', schema);

        return Model.create({ name: 'test' });
      })
      .then(doc => console.log(doc));

  });
}

@varunjayaraman Je viens de mettre à jour Mongoose et d'utiliser useMongoClient: true comme vous le suggérez, mais j'ai un problème.
Il ne prend pas en charge, selon la documentation officielle de Mongoose , les options user et pass :

the options [user] is not supported
the options [pass] is not supported

Et, oui, n'a pas réussi à s'authentifier. :-1:

Je vais essayer d'ajouter un utilisateur et de transmettre la chaîne de connexion à la place.
Cela fonctionne lorsque j'ajoute un nom d'utilisateur et un mot de passe dans la chaîne de connexion. Peut-être devriez-vous mettre à jour la documentation. 😐

@itpcc essayer d'utiliser la version 4.10.8 est la meilleure solution pour le moment.

npm remove mongoose
npm install [email protected] --save

Crédit : @ Chenz62

@CQBinh Merci pour vos conseils. J'ai déjà lu ces commentaires à ce sujet.
Cependant, je ne pense pas que l'utilisation de l'ancienne version soit la meilleure solution pour le moment. Et il peut résoudre en insérant dans la chaîne de connexion.
Je me sens juste confus parce que cela a été mentionné dans le document mais cela ne fonctionne pas. :/
BTW, je signale comme un nouveau problème ici

@varunjayaraman si db.model n'est plus présent, comment gérer plusieurs connexions de mangouste différentes avec différents modèles ?

par exemple model1 et model2 attachés à mongooseConnection1 et model3 et model4 attachés à mongooseConnection2.

Auparavant, cela se faisait en appelant mongoose.createConnection pour chacune des connexions et en attachant les modèles à chacune de ces valeurs de retour.

Edit : Ou est-ce que ça marche toujours dans ce cas :

const conn = mongoose.createConnection(...);
const Model = conn.model('ModelName', schema);

+1

@boyce-ywr SÉRIEUSEMENT, un autre +1 ??? Qu'est-ce qui ne va pas chez vous ??
Postez des commentaires constructifs, pas des trucs comme ça.

En ce qui concerne la mangouste, je ne sais pas si la méthode mongoose.connect() sera remplacée ou non dans les futures versions. Quelqu'un pourrait-il expliquer s'il vous plait ?

@simonemazzoni Vous avez raison, ils nous spamment.

Si vous souhaitez être inclus dans les notifications de ce fil, il vous suffit de vous y abonner (il y a un bouton en haut du fil),

Lorsque vous attribuez +1 , tout ce que vous faites est d'envoyer à tout le monde ici un e- mail disant

Salut je suis là!

On s'en fiche , on attend des commentaires constructifs et une solution .

Aussi, pourquoi ne supprimez-vous pas tous vos +1 de cette liste, ils sont une horreur et une douleur à l'arrière pour avoir à faire défiler juste pour accéder aux vrais commentaires.

Comme certaines personnes l'ont déjà dit, la seule "solution" est de revenir à [email protected]_ ...
Au moins pour l'instant!

Ressemble à un bogue, est retourné à [email protected] pour résoudre le problème

Utilisez mongoose.createConnection(...) au lieu de mongoose.connect(...)

Voici un exemple de travail complet d'utilisation de [email protected] basé sur la recommandation de @diegoazh

const mongoose = require('mongoose')
mongoose.Promise = require('bluebird')  // optional, use this to get rid of 
                                        // the mpromise DeprecationWarning
const conn = mongoose.createConnection('mongodb://localhost/testDB')
const Schema = mongoose.Schema

const UserSchema = new Schema({
    username: String,
    email: String
})

const User = conn.model('User', UserSchema)
module.exports = User

@midnightcodr Donc, nous abandonnons simplement la connexion et utilisons createConnection à la place?

@bertolo1988, tout comme ppl l'a suggéré sur ce problème, il existe actuellement deux solutions de contournement

1. Revenir à 4.10.8
2. Utilisez le nouveau modèle si vous souhaitez vous en tenir à la nouvelle version

const conn = mongoose.createConnection(...)
const Model = conn.model(...)

Personnellement, je préfère la deuxième solution.

Merci!!!
résolu par createConnection, et utilisez cette connexion pour créer un modèle (au lieu de mangouste)

let mongoose = require('mongoose');

mongoose.Promise = global.Promise;

module.exports = mongoose;

const mongoose = require('./set-mongoose');
module.exports = mongoose.createConnection('mongodb://localhost/advisorDemoTestDB');

Le nouveau modèle de connexion nécessite quelques modifications de code, et selon la taille de votre projet, cela peut signifier beaucoup de temps et peut-être même des changements d'architecture (étant donné que la création d'un modèle nécessite une connexion).

Cela aurait été formidable si l'ancien modèle de connexion pouvait envelopper le nouveau modèle de connexion.

Il y a beaucoup de post, alors je peux essayer de résumer :

1. L'avertissement est un avertissement obsolète, ce qui signifie qu'il n'y a pas d'urgence. Si nous ne changeons rien, il fonctionnera toujours comme il l'a toujours fait, tout semble aller bien

2. Selon l'avertissement, connect() va être/a été modifié et passer useMongoClient va être un must. Mais voici le bug/problème possible

• connect('myurl', {useMongoClient: true}) => le document arrête de se charger et il n'est pas possible d'écrire dans la base de données

• connect('myurl', {useMongoClient: false}) => semble fonctionner correctement mais l'avertissement est toujours affiché

Le but de ce problème est donc de corriger l'utilisation de useMongoClient en cas d'appel de la méthode connect.

Accepter?

Pourtant, alors qu'un avertissement de dépréciation est en effet "juste" un avertissement, le fait que cela apparaisse me fait me demander quand il va réellement être supprimé. Si la mangouste suit semver, elle devrait toujours être là dans la branche 4.x. Par conséquent, il devrait toujours fonctionner avec une rétrocompatibilité jusqu'à la sortie de la version 5.x.

En ce qui concerne le changement lui-même, c'est un peu ennuyeux de ne rien trouver rapidement concernant ce changement, sauf celui mentionné dans le journal des modifications. Et même lorsque vous le modifiez, des choses se cassent toujours et selon plusieurs personnes ici, c'est à cause de l'appel .model() .

De plus, même les documents affichent toujours mongoose.connect() et mongoose.model() , ce qui rend cette question encore plus confuse. La modification mongoose.connect() n'est mentionnée que sous les pools de connexion, et pas sur les autres parties de cette page . La question demeure donc, est-ce que ce changement est un bogue ou est-il intentionnel ?

Je ne sais pas où cela mène, mais j'ai passé la majeure partie de ce week-end à essayer d'établir une connexion avec l'Atlas de MongoDB. Le pilote natif mongodb était instantanément opérationnel et exécutait le truc CRUD.

Cependant, essayer de faire avancer la mangouste est un cauchemar total. Si j'utilise createConnection avec 4.11, les connexions du cluster sont supprimées :

MongoError: connection 4 to cluster0-myshard.mongodb.net:27017 closed

Alternativement, je pourrais définir

useMongoClient: true

mais ensuite je reçois indéfini sur le connection.model

<info> atlas-api-test.js:65 (Test.testVendors) conn.model undefined

@Archomeda ne prévoit pas de supprimer le comportement de connexion hérité dans 4.x, et 5.x est bloqué lors de l'obtention de la nouvelle logique de connexion à un état stable. Il existe des documents sur les documents de connexion que 4.11.1 améliorera et un lien vers cela devrait être utile. Re : l'appel model() , si vous spécifiez useMongoClient: true , createConnection() ne renverra pas de connexion, mais plutôt une promesse qui se résout en une connexion dont vous avez besoin pour .then() sur. La justification est décrite ici : https://github.com/Automattic/mongoose/issues/5404#issuecomment -312522539 N'hésitez pas à exprimer toute préoccupation à ce sujet sur le problème #5404 .

@mkastner semble que vous utilisez createConnection() . Avec useMongoClient: true , createConnection() renvoie une promesse qui se résout en une connexion. Veuillez utiliser await mongoose.createConnection() ou mongoose.createConnection().then()

@peterpeterparker #5404 a signalé un problème avec la nouvelle logique de connexion qui sera corrigée dans la version 4.11.1, qui sera publiée dans les prochaines 24 heures.

@ cosminn777 quels problèmes d'architecture rencontrez-vous ? Veuillez ouvrir un sujet séparé pour en discuter. Le plan à long terme est que dans 5.x, nous ne prendrons pas en charge Node < 4, donc tout le monde utilisant la mangouste aura un accès natif aux générateurs et/ou async/wait, donc ce changement serait aussi simple que d'ajouter un yield ou await .

@alanpurple , le problème auquel vous faites référence est le même que celui mentionné # 5404 et sera résolu avec 4.11.1.

@itpcc J'ai ouvert un problème séparé pour suivre # 5432. Pour l'instant, veuillez mettre votre nom d'utilisateur/mot de passe dans l'URI : var dbURL = mongodb://${dbUser} :${dbPass}@${dbHost} :${dbPort}/${dbName}?authSource= admin`.

En général, merci à tous pour votre patience dans l'essai de ce nouveau comportement. Je me rends compte que le basculement causera des maux de tête, c'est pourquoi nous avons caché ce comportement derrière un indicateur, mais certains changements à venir pour MongoDB 3.6 nécessitent une refonte complète de la logique de connexion interne de mongoose. J'espère que la nouvelle logique de connexion conduira à moins de bogues de connexion spécifiques à la mangouste à long terme, mais veuillez patienter avec nous pendant que nous affinons le comportement et la documentation. Vos commentaires sont très appréciés.

Tant que vous êtes sur 4.x, votre logique de connexion actuelle fonctionnera, elle imprimera simplement un avertissement. En attendant, n'hésitez pas à signaler tout problème que vous rencontrez dans un problème github séparé.

Je viens d'adopter la nouvelle méthode et ça marche très bien. Merci tout le monde!

@vkarpov15 merci pour les précisions.

En tant que FYI, le même avertissement de dépréciation est également émis avec openSet (j'utilise un jeu de répliques).

Donc, pour résumer, il est prudent d'ignorer cet avertissement pour l'instant car il ne concerne que le fonctionnement interne de Mongoose, et nous pourrions essayer d'utiliser useMongoClient mais ce n'est pas encore nécessaire.

Quelle est sa stabilité pensez-vous? Est-il sûr à utiliser? Je ne voudrais pas passer 2 heures à refactoriser tous nos modèles et notre logique de connexion pour découvrir qu'il est encore inutilisable en production.

Est-il possible de supprimer l'avertissement d'obsolescence jusqu'à ce que l'utilisation de l'indicateur soit stable et la méthode recommandée pour se connecter à l'avenir ? Ou ce point a-t-il déjà été atteint ?

@vkarpov15

Mais j'utilise async sur createConnection. J'ai mis en place deux tests contre le serveur de base de données. Le premier est le test canari natif mongo-js pour s'assurer que l'url fonctionne et que je peux écrire et lire:

tape('test connection via mongo native', async function testMongoConnection(t) {

  try {

    t.plan(1);
    let db = await MongoClient.connect(dbURL);
    await db.collection('users').insert({name: 'username'});
    let result = await db.collection('users').find({});
    let docs = await result.toArray();
    log.info('result', await result.toArray());
    t.equal(1, docs.length);
    db.collection('users').remove({});

    await db.close();

  } catch (err) {
  console.error(err)
  }
});

Résultat:

2017-07-04T09:00:34+0200 <info> atlas-api-test.js:28 (Test.testMongoConnection) result [ { _id: 595b3d1146734207bad88f9d, name: 'username' } ]
✔ should be equal

Réussi par le test de la mangouste à l'aide de la mangouste createConnection avec await :

tape('test connection via mongoose', async function testMongooseConnection(t) {

  try {
      let conn = await mongoose.createConnection(dbURL, {
        useMongoClient: true,
        /*
        // tried these settings too
        user: 'myUserName',
        pass: 'myPassword',
        connectTimeoutMS: 30000,
        rs_name: 'myReplSetName',
        ssl: true,
        auto_reconnect: true,
        */
      });

      let UserSchema = new mongoose.Schema({
        name: String,
      });

      let User = mongoose.model('User', UserSchema);
      let newUser = new User({name: 'username'});
      let createdUser = await newUser.save();

      // just ending test without validating any results
      t.end();

  } catch (err) {
    log.error(err);
  }

});

Et il jette l'erreur suivante :

/mypath/node_modules/mongodb/lib/replset.js:390 process.nextTick(function() { throw err; })
                                    ^
MongoError: connection 8 to cluster0-shard-00-02-c4nst.domain.com:27017 closed at Function.MongoError.create (/mypath/node_modules/mongodb-core/lib/error.js:29:11)
at Socket.<anonymous> (/mypath/node_modules/mongodb-core/lib/connection/connection.js:202:22)
at Object.onceWrapper (events.js:316:30)
at emitOne (events.js:115:13)
at Socket.emit (events.js:210:7)
at TCP._handle.close [as _onclose] (net.js:549:12)`

Je me trompe peut-être terriblement ici, mais pour moi, cela ne ressemble pas à un problème async/promesse;

J'utilise Mongo Atlas. Lorsque j'utilise {useMongoClient : true}, mon application se connecte avec succès à la base de données, mais la base de données ne répond pas à l'application, n'est-ce pas ?

Mon code :
mongoose.connect(config.dbhost, {useMongoClient: true}, function(err){ if(err){ console.log(err); } else { console.log('connected to the database successfuly.'); } });

Juste un avis pour tout le monde car je ne l'ai pas vu mentionné ici : 4.11.1 a été publié et après un rapide coup d'œil, il semble que le problème de mise en mémoire tampon lors de l'utilisation de useMongoClient=true a été corrigé. Je testerai plus demain. Quelqu'un d'autre?

Quelle est la solution finale ?

Cela a fonctionné pour moi (v.4.11.1):

base de données.js

mongoose.connect(databaseUri, { useMongoClient: true })
      .then(() => console.log(`Database connected at ${databaseUri}`))
      .catch(err => console.log(`Database connection error: ${err.message}`));

user.model.js

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const userSchema = new Schema({ ... });
const User = mongoose.connection.model('User', userSchema);

METTRE À JOUR

Il n'est peut-être pas nécessaire de référencer la connexion lors de l'initialisation de votre modèle (merci, @kyrylkov @peterpeterparker):

user.model.js

const User = mongoose.model('User', userSchema);

Quelqu'un pourrait-il expliquer brièvement à quoi sert exactement { useMongoClient: true } ou à quoi sert cet indicateur ?

Je suis un peu perdu, quel est l'avantage de l'utiliser ?

Je veux dire, comme je l'ai déjà dit, je pourrais vivre avec l'avertissement, donc je ne me sens pas pressé d'ajouter ce paramètre.
Je n'ai pas trouvé grand-chose dans la doc, merci d'avance de clarifier cela.

@Blackbaud-SteveBrush Cela ne fonctionne pas. J'utilise Mongo Atlas. Pourquoi ça ne marche pas ?

@Thinkdiff

Ça marche pas comment ? Cela fonctionne pour nous sur mLab et MongoDB Atlas avec d'habitude :

const User = mongoose.model('User', userSchema);

au lieu de:

const User = mongoose.connection.model('User', userSchema);

Si j'essaie d'activer l'option useMongoClient avec quelques hôtes définis dans l'URI, il se bloque puis génère une erreur :
MongoError: no mongos proxy available at Timeout._onTimeout (/home/ubuntu/code/pss/node_modules/mongoose/node_modules/mongodb-core/lib/topologies/mongos.js:636:28) at ontimeout (timers.js:386:14) at tryOnTimeout (timers.js:250:5) at Timer.listOnTimeout (timers.js:214:5) name: 'MongoError', message: 'no mongos proxy available'
uri : mongodb://10.0.1.49 , 10.0.2.158, 10.0.3.84/pss
options : { useMongoClient : vrai, autoReconnect : vrai, keepAlive : 300000, connectTimeoutMS : 30000 }

Pour toute personne intéressée, voici les docs Mongoose sur le paramètre useMongoClient : http://mongoosejs.com/docs/connections.html#use -mongo-client

"La logique de connexion par défaut de Mongoose est obsolète à partir de 4.11.0... Cette obsolescence est due au fait que le pilote MongoDB a obsolète une API essentielle à la logique de connexion de Mongoose pour prendre en charge MongoDB 3.6, consultez ce problème github pour plus de détails." Voici le problème GitHub : https://github.com/Automattic/mongoose/issues/5304

@Blackbaud-SteveBrush merci d'avoir signalé que notre. Donc si j'ai bien compris

useMongoClient = true => active la nouvelle logique de connexion qui fonctionnera également avec Mongo 3.6
useMongoClient = false => valeur par défaut. ancienne logique de connexion < 4.11.0. celui qui est obsolète.

droit?

@Blackbaud-SteveBrush à propos de votre morceau de code, dans mon cas je n'utilise pas

const User = mongoose.connection.model('User', userSchema);

mais

const User = mongoose.model('User', userSchema);

et c'est quand même réussi. THX

Mongoose fonctionne pour moi 4.10.8 :|

J'ai trouvé que c'est probablement un bug avec la mangouste

le problème a disparu après avoir annulé la version mangouste

npm désinstaller - enregistrer la mangouste
npm install -save [email protected]

J'ai complètement ignoré cet avertissement et tout fonctionne comme prévu. Peut-être que c'est la solution pour l'instant. Ignorez simplement.

revenir à 4.10.8 a permis à ma connexion de fonctionner à nouveau, mais j'obtiens toujours l'erreur

Db.prototype.authenticate method will no longe against users in the admin db and will no long connect with auth credentials.

@peterpeterparker correct. Le code d'authentification actuel de Mongoose ne fonctionnera pas sur mongodb 3.6 d'après ma compréhension, donc useMongoClient nous représente en train d'essayer de devancer ce problème tout en maintenant la rétrocompatibilité. Autant que je sache, il n'y a pas encore de date de sortie prévue pour mongodb 3.6, donc le changement n'est pas pressant.

@adamreisnz, nous avons eu quelques bogues, mais la nouvelle logique de connexion est vraiment un wrapper très fin utilisant la fonction MongoClient.connect() du pilote natif, qui est la méthode préférée pour se connecter à mongodb depuis quelques années maintenant. Une fois votre connexion établie, la même logique de pilote mongodb maintient la connexion. useMongoClient ne devrait affecter que la connexion initiale.

@vkarpov15 merci beaucoup pour l'explication et bien sûr pour le travail, vraiment apprécié !

@ vkarpov15 merci, je vais essayer et passer à l'utilisation useMongoClient et voir où cela nous mène.

const mangouste = require("mangouste");
const db = " mongodb://localhost/testaroo ";

mongoose.connection.openUri(db);
mongoose.connection.once("ouvrir", fonction () {
console.log("connexion établie");
}).on("erreur", fonction (erreur) {
console.log (erreur);
})

--j'utilise ceci et aucune erreur n'a été trouvée

var mongoose = require('mongoose');
mongoose.Promise = global.Promise;

var mongoDB = mongoose.connect('mongodb://your_database', {
    useMongoClient: true
});

mongoDB
    .then(function (db) {
        console.log('mongodb has been connected');
    })
    .catch(function (err) {
        console.log('error while trying to connect with mongodb');
    });

module.exports = mongoDB;

J'utilise ceci et aucune erreur n'a été trouvée

@vitorbarros Cela a fonctionné pour moi. Merci!

Ça marche pour moi:
http://mongoosejs.com/docs/connections.html#use-mongo-client

J'ai exécuté ce test rapide et cela a fonctionné:

// index.js
const mongoose = require('mongoose')
mongoose.Promise = global.Promise;
const db = mongoose.createConnection(`mongodb://localhost/test`)

db.on('error', err => console.log(err))
db.once('open', () => {
  console.log(`Connected to Mongo at: ${new Date()}`)
  db.close(() => {
    console.log(`Disconnected from Mongo at: ${new Date()}`)
  })
})

alors node index.js me donne :

Connected to Mongo at: Thu Jul 13 2017 22:54:50 GMT+0000 (UTC)
Disconnected from Mongo at: Thu Jul 13 2017 22:54:50 GMT+0000 (UTC)

Merci à tous!

@vitorbarros votre solution fonctionne ! Merci.

Je peux confirmer qu'avec 4.11.3, le remplacement de la logique de connexion par ce que @vitorbarros a suggéré supprime les avertissements et semble bien fonctionner 👍

Il n'est pas nécessaire de refactoriser les références de modèle comme suggéré précédemment ici dans ce fil.

La solution de @vitorbarros est en effet la méthode recommandée selon la documentation "The useMongoClient Option" .

Cependant, notez que mongoose.Promise = global.Promise; ne promet _pas_ le pilote Mongo sous-jacent . Selon la documentation "Promises for the MongoDB Driver" , la propriété promiseLibrary doit également être définie dans l'objet options de la méthode connect .

Par exemple:

var mongoDB = mongoose.connect('mongodb://your_database', {
    useMongoClient: true,
    promiseLibrary: global.Promise
});

global.Promise utiliserait le moteur de promesse natif. Naturellement, il est également possible d'utiliser Bluebird ou tout autre moteur, par exemple promiseLibrary: require('bluebird')

La solution @vitorbarros fonctionne pour moi. Et nous devons également utiliser promiseLibrary comme l'a dit @boaz-amit.
Mais quelle est la meilleure façon d'utiliser les données d'authentification ?
Dans URL

mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]

ou mieux définir l'utilisateur et le mot de passe dans les options ? Je ne trouve pas le bon endroit pour l'instant.

Ce n'est qu'une façon de s'authentifier ?

Et voici ma solution. Cela fonctionne également même si la première connexion échoue.

let firstConnectTimeout = null;
const mongoConnect = () => {
    const mongoDB = mongoose.connect('mongodb://localhost/test', {
        useMongoClient: true
    });

    mongoDB
        .then((db) => {
            clearTimeout(firstConnectTimeout);
        })
        .catch((err) => {
            firstConnectTimeout = setTimeout(mongoConnect, 5000);
        });
};

mongoConnect();

Il doit être en url, les options user/pass ne fonctionnent plus avec
useMongoClient true j'ai trouvé.

Le lundi 17 juillet 2017, 20:28 Andrey Prisniak [email protected]
a écrit:

La solution @vitorbarros https://github.com/vitorbarros fonctionne pour moi. Et
nous devons également utiliser promiseLibrary comme @boaz-amit
https://github.com/boaz-amit dit.
Mais quelle est la meilleure façon d'utiliser les données d'authentification ? Dans URL
mongodb://[ nom d' utilisateur: mot de passe @
]hôte1[:port1][,hôte2[:port2],...[,hôteN[:portN]]][/[base de données][?options]]
ou mieux définir l'utilisateur et le mot de passe dans les options ? je ne trouve pas le bon endroit pour
à présent.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/Automattic/mongoose/issues/5399#issuecomment-315694642 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AAd8Qup1YY4lhUhQccv2kLKtraARxvP0ks5sOxs_gaJpZM4OEnIt
.

@adamreisnz @aprisniak y travaille, voir #5419. En attendant, veuillez mettre le nom d'utilisateur et le mot de passe dans votre URI : mongodb://user:pass<strong i="7">@hostname</strong>:port/db

De plus, j'ai écrit un article de blog sur cette option et pourquoi elle est nécessaire : http://thecodebarbarian.com/mongoose-4.11-use-mongo-client.html

@ vkarpov15 J'utilise user:pass in URI, mais j'ai toujours l'avertissement.

Pour ceux qui utilisent mongoose avec gridfs-stream :

const mongooseConnect = mongoose.connect(
    process.env.MONGODB_URI || process.env.MONGOLAB_URI,
    {
        useMongoClient: true
    }
)

let gfs
mongooseConnect.then(conn => {
    gfs = Grid(conn.db)
    /** Setting up GFS storage here */
})

Puissiez-vous ajouter l'option de connexion manquante "useMongoClient" lors des saisies dactylographiées", et ajouter des saisies à ce projet à la place pour ajouter des packages de saisies.

Je ne sais pas si je dois faire quelque chose avec cet avertissement ou non ? Ce sera corrigé, non ?

J'ajoute juste le useMongoClient dans les typages pour le faire fonctionner. @iamdubx

@FinalDes comment ? J'ai ajouté mongoose.connect(process.env.DATABASE, { useMongoClient: true }) mais j'ai toujours le message. Et j'utilise user:pass in URI

La meilleure façon de se débarrasser de ce problème est d'utiliser ces deux commandes :
npm désinstaller - enregistrer la mangouste
npm install -save [email protected]

NB : [email protected] est la version stable.

Comment gérez-vous tous la création de votre schéma et de votre modèle ainsi que leur accès ?

J'ai essayé tous les correctifs du fil. Avec l'avertissement, tout fonctionne bien. Une fois que j'ai essayé useMongoClient: true ou mongoose.createConnection , l'avertissement est supprimé et je peux me connecter à la base de données, mais tout code qui tente d'accéder au modèle ne se déclenche pas. Il n'y a pas d'erreurs, le code ne s'exécute jamais.

@iamdubx
manque juste les frappes, donc lorsqu'il est exécuté avec "noImplicitAny": true , n'aura pas d'erreur

import mangouste = require("mangouste");
import dotenv = require("dotenv");
dotenv.config();
mongoose.Promise = global.Promise;
const MONGO_URI=`mongodb://${process.env.MONGODB_HOST}:${process.env.MONGODB_PORT}/${process.env.MONGODB_DB}` ;
mongoose.connect(MONGO_URI, {
useMongoClient : vrai,
});

@FinalDes à quoi faites-vous référence ? Quelles saisies manquantes ? J'ai le même code ci-dessus et j'ai une erreur.

J'ai rencontré le même problème avec @Snow-Okami

1. const mongoDB = mongoose.connect(config.database, { useMongoClient: true });
   Cela supprime l'avertissement et se connecte à la base de données. Cependant, tout ce qui tente d'accéder au modèle échoue (get/post). Aucune erreur ne revient.
2. const mongoDB = mongoose.connect(config.database, function(){ useMongoClient: true });
   Et cela donne ces deux avertissements, mais tout autre que cela fonctionne bien.

Veuillez au moins donner la rétrocompatibilité de notre serveur de construction de production échoue.
la mise à jour des fonctionnalités est bonne mais ne modifiez pas la signature ou l'appel de la méthode.

@Nikunjksanghavi Ce n'est qu'un avertissement, rien ne devrait échouer.

@iamdubx quel genre d'erreur?

Erreur d' obsolescence @FinalDes , de quoi d'autre parlons-nous dans ce sujet ?

Cela a fonctionné pour moi: (v.4.11.4)

const MONGO_URI = process.env.MONGO_URI
const mongoose = require('mongoose');

// Use your own promis library
mongoose.Promise = require('bluebird');

// connect to mongo, use Mongo Client
mongoose.connect(MONGO_URI, {useMongoClient: true})
  .then(({db: {databaseName}}) => console.log(`Connected to ${databaseName}`))
  .catch(err => console.error(err));

const poemSchema = mongoose.Schema({
    name: String,
    text: String
});

const Poem = mongoose.model('Poem', poemSchema);

const insertPoem = poem =>
  (new Poem(poem)).save( (err, newPoem) => 
    console.log(err || newPoem));

insertPoem({name: 'poemName', text: 'this is a poem'})

// Connexion BD
var mangouste = require('mangouste');
mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost/login_register', {
useMongoClient : vrai
})
.then(() => console.log('connexion réussie'))
.catch((err) => console.error(err));
// Fin de la connexion à la BD

Cela ne fonctionne pas pour moi. J'ai toujours l'avertissement de la console. Et aucune explication claire ne fournit.

La mangouste est horrible. Aussi le pire site de documentation que j'ai vu dans les bibliothèques si populaires. C'est dommage!

Maintenant, je pense passer à RethinkDB. Fondation Linux - c'est sérieux.
Aussi Postgre génial.

Mongo - très, très honte.

@iamdubx avez-vous essayé ma solution ci-dessus ? Pourriez-vous coller l'avertissement dessus? Je pourrais peut-être aider :)

@iamdubx peut poster votre message d'avertissement ?

@FinalDes @shams-ali que j'ai posté auparavant, c'est la même erreur de dépréciation que le sujet. Celui dont parle ce topic !

(node:3304) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, or set the `useMongoClient` option if using `connect()` or `createConnection()`. See http://mongoosejs.com/docs/connections.html#use-mongo-client
Server listening on port: 7777
Db.prototype.authenticate method will no longer be available in the next major release 3.x as MongoDB 3.6 will only allow auth against users in the admin db and will no longer allow multiple credentials on a socket. Please authenticate using MongoClient.connect with auth credentials.

@iamdubx intéressant, c'est le même avertissement que j'ai eu et la solution ci-dessus que j'ai publiée a semblé résoudre le problème pour moi. Pourriez-vous coller votre code mis à jour qui ne fonctionne pas ?

C'est ce qui a fonctionné pour moi:

// ES6 promises
mongoose.Promise = Promise;

// mongodb connection
mongoose.connect("mongodb://localhost:27017/sandbox", {
  useMongoClient: true,
  promiseLibrary: global.Promise
});

var db = mongoose.connection;

// mongodb error
db.on('error', console.error.bind(console, 'connection error:'));

// mongodb connection open
db.once('open', () => {
  console.log(`Connected to Mongo at: ${new Date()}`)
});

@afoke fonctionne merci

@FinalDes Tu es le bienvenu mon pote.

Ceci est mon nouveau flux de travail, essayant d'être conforme aux avertissements et aux obsolescences :

// db.js
const model = require('./model');
const mongoose = require('mongoose');
mongoose.Promise = global.Promise;


async function db(uri) {
  const con = await mongoose
    .createConnection(uri, {
      useMongoClient: true,
    });

  const {User} = model(con);

  // do something with User
  ...

  // the interface for the server
  return {
    create: params => User.create(params),
    ...
  };
}


module.exports = db;

Et maintenant le module models renvoie une fonction de connexion

// model.js
const {Schema} = require('mongoose');


const UserSchema = new Schema({
  name: String,
  age: Number,
});

// Other Schemas
...

module.exports = con => ({
  User: con.model('User', UserSchema),
  ...
});

Des directives officielles sur le sujet?

@iamdubx On dirait que vous ne comprenez pas la différence entre un avertissement et une erreur .

L' avertissement en question ne casse rien, mais avertit l'utilisateur de quelque chose qui sera supprimé dans la prochaine version majeure.

La mangouste est horrible.

Gardez donc à l'esprit que vous avez cette réaction lorsque les développeurs vous avertissent à l'avance avant de supprimer une fonctionnalité. Je vous exhorte également à vous rappeler que vous l'utilisez gratuitement, alors donnez peut-être aux développeurs le bénéfice du doute avant de faire une crise de colère

@chrisdothtml

L'avertissement en question ne casse rien, mais avertit l'utilisateur de quelque chose qui sera supprimé dans la prochaine version majeure.

Il pollue les tests et la console, ce qui est légèrement ennuyeux.

La mangouste est horrible. Aussi le pire site de documentation que j'ai vu dans les bibliothèques si populaires. C'est dommage!

Il est impoli, ce qui est également légèrement ennuyeux, mais il fait valoir un point très valable en ce qui concerne la documentation de Mongoose. Ce n'est pas la pire documentation de tous les temps, mais elle pourrait vraiment être améliorée.

Le fait que mongoose transmette l'API client mongo. qui fonctionne d'une manière très différente, rend l'utilisation et la documentation de Mongoose confuses.

Une solution possible pour cela serait:

• arrête de le faire
• supprimer la documentation des méthodes du client Mongo
• fournir un moyen de partager la connexion entre le client officiel et Mongoose

Je suggérerais également d'améliorer la capacité de recherche des documents en les divisant en plusieurs pages et en donnant plus d'informations aux nouveaux utilisateurs sur ce que fait réellement Mongoose pour obtenir certains des résultats.

J'ai eu cette erreur, mais elle a disparu après avoir ajouté l'option {useMongoClient: true}.
J'utilise Debian 9, version de test, avec MongoDb ver. 3.2.11 et mangouste ver. 4.10.4.
J'ai le message "Connecté à MongoDB" (voir le code dans Typescript ci-dessous), tout fonctionne parfaitement.

(< n'importe quelle> mangouste).Promise = global.Promise;
mongoose.connect(process.env.MONGODB_URI, {useMongoClient : vrai});
const db = mangouste.connexion;
db.on('error', console.error.bind(console, 'erreur de connexion :'));
db.une fois('ouvrir', () => {
console.log('Connecté à MongoDB');
setRoutes(app);
app.get('/*', function(req, res) {
res.sendFile(path.join(__dirname, '../public/index.html'));
});
app.listen(app.get('port'), () => {
console.log('MonApp écoute sur le port ' + app.get('port'));
});
});

Désinstallez simplement la version actuelle de mongoose que vous avez et installez la version inférieure npm install [email protected] --save . Pas besoin de faire quoi que ce soit d'autre, cela fonctionnera certainement pour vous.

mongoose.connect(database.host, { useMongoClient: true });

Cela a résolu mon problème. Mais j'ai eu un autre avertissement après avoir fait ce changement.

DeprecationWarning : Mongoose : mpromise (la bibliothèque de promesses par défaut de mongoose) est obsolète, branchez plutôt votre propre bibliothèque de promesses : http://mongoosejs.com/docs/promises.html

Ce code résout tous les avertissements d'obsolescence :
```javascript
mongoose.Promise = global.Promise;
mangouste.connect(uri, {
keepAlive : vrai,
reconnectTries : Number.MAX_VALUE,
useMongoClient : vrai
});
````
Plus d'infos par le lien -> http://mongoosejs.com/docs/connections.html#use -mongo-client

@bricss Fantastique ! Merci!

@bricss Vous avez fait ma journée.

quelqu'un a gagné un badge de héros...

edit: @bricss Cela a éliminé les avertissements de dépréciation pour moi, mais je n'ai pas pu récupérer les données de mes bacs à sable mLab. C'est peut-être parce qu'ils utilisent une ancienne version de MongoDB. J'essaierai de vérifier plus tard.

edit: @bricss Cela fonctionne maintenant correctement avec la dernière mangouste 4.11.9 et une connexion à Cosmos DB sur Azure.

@bricss : Briques bien faites ! Cela a fonctionné pour moi même si j'utilise une très ancienne version de mongodb dans mon local :+1:

@bricss Awesowe ! Mais vous pourriez envisager de mettre un nombre plus petit pour "reconnectTries". Vous ne voulez pas passer toute la journée à vous reconnecter en cas de problème avec votre base de données.

La solution de @afoke a fonctionné pour moi, uniquement lorsque je déclare explicitement la base de données dans la chaîne de connexion, c'est-à-dire mongodb://localhost:27017/test mais pas mongodb://localhost:27017

Puis-je créer une connexion à 2 DB sans cet avertissement ? J'ai besoin d'utiliser mes modèles avec différentes bases de données.

En utilisant mongoose v^4.11.6 , une fois ajouté useMongoClient l'avertissement a disparu.

const uri = "http://blablabla.blo/blaDB"; mongoose.Promise = global.Promise; mongoose.connection.on('error', (err) => { console.error( Erreur de connexion Mongoose : ${err}` );
process.exit(1);
});
mongoose.connect(uri, {useMongoClient : vrai});

 // load models
 require('./model1');
 // ...
 require('./modelN');`

se connecter à la base de données de cette manière résout le problème :
mongoose.connect(url,{user:'username',pass:'mypassword',useMongoClient:true});

Ces erreurs causeront-elles des problèmes, par exemple en matière de sécurité ?

Plus aucun avertissement "obsolète" ne s'affiche si j'utilise cette syntaxe 🎉

mongoose.connection.openUri('mongodb://localhost/test')
  .once('open', () => console.log('Good to go !'))
  .on('error', (error) => {
    console.warn('Warning', error);
  });

J'ai fait face au même avertissement d'obsolescence que ci-dessous :
(node:2300) DeprecationWarning : open() est obsolète dans mongoose >= 4.11.0, utilisez openUri() la place, ou définissez l'option useMongoClient si vous utilisez connect() ou createConnection() . Voir http://mongoosejs.com/docs/connections.html#use -mongo-client

Solution

J'ai essayé ce qui suit et cela fonctionne bien. Ne donne aucun avertissement de dépréciation.

mongoose.connect('mongodb://127.0.0.1:27017/your-database-name', { useMongoClient: true, promiseLibrary: global.Promise });

J'espère que cela aidera tous ceux qui sont confrontés à ce problème.

J'ai le même problème, mais lorsque j'essaie de me connecter au service Mongo Atlas, il ne se connecte tout simplement pas avec l'option {useMo ngoClient:true } et sans elle, la connexion n'est plus exécutée.

Quelqu'un avec le même problème?

J'avais résolu mon problème en changeant simplement le mongoose.connect en mongoose.createConnection

mongoose.createConnection(config.uri, (err) => {
si (erreur) {
console.log('Impossible de se connecter à la base de données : ', err);
} autre {
console.log('Connecté à la base de données : ' + config.db);
}
});

J'ai résolu ce problème comme ça (Mongoose 4.12.0, NodeJS - 7.10.1)

mongoose.Promise = require('bluebird');
mongoose.connect('mongodb://localhost:27017/books_exchange', {
  useMongoClient: true,
  promiseLibrary: require('bluebird')
}).then(() => {
  var userSchema = new mongoose.Schema({
    name: String,
    password: String
  });
  var User = mongoose.model('User', userSchema);

  var person = new User({
    name: "John",
    password: "qwerty"
  });

  person.save().then(() => {
    console.log('Data saved');
  }).catch(e => {
    console.log(e);
  });
}).catch(e => {
  console.log('Error while DB connecting');
  console.log(e);
});