Mongoose: Avertissement: Mongoose: mpromise (la bibliothèque de promesses par défaut de mangouste) est obsolète avec 4.8.0 et 4.8.1

Pouvez-vous coller le code qui produit réellement l'erreur? Ce code ne fonctionnera pas car vous n'avez pas encore utilisé de promesse (à moins que vous ne disiez que l'extrait de connexion que vous avez publié produit l'avertissement?)

Non, l'extrait de connexion ne produit pas l'avertissement. L'extrait de sauvegarde newuser suivant est le code qui génère l'avertissement, mais uniquement la première fois que le code est exécuté après le démarrage de l'application (encore une fois, l'avertissement ne se produit pas dans les versions de mangouste 4.7.9 et antérieures):

 `                       var curDate = new Date();

                         var newuser = new user(
                         {                             
                                "userName": userName,
                                "hashed_password": hashed_password,
                                "emailReg": false,
                                "email": "~",
                                "firstName": "",
                                "lastName": "",
                                "address.streetAddress": "",
                                "address.city": "",
                                "address.state": "",
                                "address.postalCode": "",
                                "phoneNumbers": [],
                                "accessLevel": 2,
                                "active": true,
                                "trialStartDate": curDate,
                                "maxStorageByteLimit": constants.maxStorageBytesPerUser,
                                "signUpDate": curDate,
                                "passwordResetDate": curDate,
                                "salt": temp,
                                "storageBytesUsed": 0
                            });

                        if (phoneNumberValid != false)
                        {
                            newuser.phoneNumbers.push({
                                "type": "mobile",
                                "number": contactPhoneNumber,
                                "primary": true
                            });
                        }

                        wlogger.crit("Create new user by UserName: " + userName);

                        newuser.save(function (err)
                        {
                            if (err)
                            {
                                wlogger.error(err + " - when saving user "
                                    + " creation by UserName: " + userName);
                                callback({
                                    "response": false,
                                    "res": "User creation failed. "
                                    + " Please try again or contact us at [email protected]"
                                });
                            }
                            else
                            {
                                wlogger.crit("Saved new user info for UserName: "
                                    + userName);

                                return callback({
                                        "response": true,
                                        "res": "Created user by User Name " + userName,
                                        "user_id": newuser._id,
                                        "last_modified_date": curDate
                                });
                            }
                        })`

Le schéma utilisateur est le suivant:

`var userSchema = mongoose.Schema({ 
token : String,
email: String,
userName: String,
deviceId: String,
devicePhoneNumber: String, 
hashed_password: String, 
hashed_admin_code: String,
maxStorageByteLimit: { type: Number, default: 1073741824 },
accessLevel: { type: Number, default: 2 },
lastAccessType: Number,
storageBytesUsed: { type: Number, default: 0 },
totalStorageBytesUsed: { type: Number, default: 0 },
deletedStorageBytesUsed: { type: Number, default: 0 },
salt : String,
salt1 : String,
temp_str: String,
syncInProcess: { type: Boolean, default: false },
syncStartDate: { type: Date, default: Date.now },
syncVersion : { type: Number, default: 0 },
active: { type: Boolean, default: false },
disabled: { type: Boolean, default: false },
emailReg: { type: Boolean, default: false },
regPending: { type: Boolean, default: false },
emailChangePending: { type: Boolean, default: false },
regCodeSendCount: { type: Number, default: 0 },
trialStartDate: Date,
signUpDate: Date,
passwordResetDate: Date,
lastLoginDate: Date,
lastModifiedDate: Date,
curLoginDate: Date,
apnDeviceTokens: [ String ],
curSessionIds: [ String ],
curIpAddr: { ipType: String, 
    upper64: Schema.Types.Long,
    lower64: Schema.Types.Long },
firstName: String,
lastName: String,
address: { streetAddress: String,
    city: String,
    state: String, postalCode: String },
phoneNumbers: [ phoneNumbersSchema ],
categories: [ categoriesSchema ],
providerCustomers: [ customerSchema ],
serviceProviders: [ providerSchema ],
ipAddrs: [ ipAddrSchema ],
recentUploads: [ recentUploadSchema ],
recentUploadsGizmo: [ recentUploadSchema ],
recentUploadsLife: [ recentUploadSchema ],
recentUploadsVehicle: [ recentUploadSchema ],
recentUploadsMisc: [ recentUploadSchema ],
recentViews: [ recentViewsSchema ],
recentAdds: [ recentAddsSchema ],
recentAddedFiles: [ recentAddedFilesSchema ],
locations: [ locationSchema ],
inMessages: [ inMessageSchema],
outMessages: [ outMessageSchema ]
  });`

Je peux confirmer le même problème avec mangouste v4.8.1 et node.js v7.5.0.

mongoose.Promise = global.Promise;
mongoose.connect(db.mongodb.uri, db.mongodb.options);

DeprecationWarning: Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead: http://mongoosejs.com/docs/promises.html

@ stevenelson74708 merci pour l'extrait, mais le schéma lui-même n'est probablement pas le problème. Ce que je cherche en plus, c'est comment le schéma est importé et utilisé par rapport au moment où la connexion est ouverte / le constructeur mongoose Promise est défini.

Le schéma est exporté à partir du fichier de schéma où il est déclaré comme suit:

`module.exports = mongoose.model('users', userSchema);   `

et le schéma est importé dans le fichier dans lequel il est utilisé où newuser.save est appelé comme suit:

`var user = require('config/models/users');`

L'extrait de connexion (où la connexion est ouverte et le constructeur mongoose Promise est défini) montré dans mon premier article se produit dans le fichier app.js qui s'exécute à l'initialisation lors du démarrage de l'application.

L'extrait newuser.save montré dans mon deuxième article est exécuté à partir du fichier dans lequel le schéma utilisateur est importé et le newuser.save est exécuté lorsqu'un utilisateur interagit avec l'application et provoque l'exécution d'une route spécifique, ce qui est bien après l'initialisation de l'application a été complété.

L'avertissement se produit uniquement la première fois que le code newuser.save s'exécute après le démarrage de l'application, même si le même code newuser.save est exécuté plusieurs fois après le démarrage, et l'avertissement ne semble pas se produire avec les versions mongoose 4.7.9 et antérieures.

@ stevenelson74708 Je vais avoir besoin de voir tous les composants qui jouent un rôle dans le démarrage de votre application. Beaucoup de gens ont récemment ouvert des problèmes à ce sujet, et chacun d'entre eux est dû à une mauvaise configuration du constructeur de promesse, donc je suppose que vous faites quelque chose de mal dans l'ordre dans lequel vous définissez mongoose.Promise .

Est-il possible que je puisse voir votre code?

Vous trouverez ci-dessous tout le code (dans l'ordre exact) de l'initialisation app.js qui est lié à la configuration de mangouste, y compris la configuration de mongoose.Promise. L'avertissement ne se produit pas lors de l'exécution du code d'initialisation. L'avertissement ne se produit que la première fois que le code newuser.save (voir dans mon article précédent) s'exécute après l'initialisation de l'application. Il y a des appels findOneAndUpdate qui s'exécutent avant l'enregistrement et qui ne provoquent pas l'avertissement, il semble donc que seule la fonctionnalité d'enregistrement provoque l'avertissement.

La configuration de la mangouste est l'une des premières choses qui se produit lors de l'initialisation. La configuration de mangouste devrait-elle se produire plus tard dans l'initialisation, par exemple après la fonctionnalité createServer?

Encore une fois, l'avertissement ne semble pas se produire dans les versions 4.7.9 et antérieures de la mangouste:

`// Set up mongoose and DB connection
var mongoose = require('mongoose');

mongoose.Promise = require('bluebird');
mongoose.connect('mongodb://localhost:27017/basedir', {server: { poolSize: 5 }});
var conn = mongoose.connection;

conn.once('open', function ()
{
    wlogger.info("Mongoose connection opened on process " + process.pid);
});`

Non, la configuration peut venir en premier. Ce fichier est-il le point d'entrée de votre application ou y a-t-il un fichier qui précède cela?

Le fichier app.js est le point d'entrée de l'application. L'application peut être appelée en tapant node app.js sur la ligne de commande.

J'ai le même problème avec la mangouste 4.8.1 et le nœud 7.5.0. J'utilise également Typescript et j'essaie de brancher Bluebird pour les promesses. J'ai découvert que l'avertissement disparaît si j'ajoute ce code:

`import * as mongoose from 'mongoose';
 import * as bluebird from 'bluebird';

 (<any>mongoose).Promise = bluebird;`

dans CHAQUE fichier qui importe quelque chose de «mangouste». Je dois donc le faire dans chaque fichier de modèle (fichier où je définis mon schéma) plutôt que dans le fichier de point d'entrée uniquement.

// Set up mongoose and DB connection
var mongoose = require('mongoose');

mongoose.Promise = require('bluebird');
mongoose.connect('mongodb://localhost:27017/basedir', {server: { poolSize: 5 }});
var conn = mongoose.connection;

conn.once('open', function ()
{
    console.log('test');
});

N'imprime pas cet avertissement, il y a donc autre chose.

@vladimirdjurdjevic cela signifie que quelque part vous utilisez une opération asynchrone mangouste avant de définir la promesse lib. Je n'utilise pas TS donc je ne sais pas si cela a quelque chose à voir avec ça.

J'ai défini la promesse lib comme indiqué ci-dessus dans le fichier app.js qui est le point d'entrée de l'application, puis lorsque le premier newuser.save est exécuté (longtemps après que la lib promise a été définie) comme indiqué ci-dessus, l'avertissement se produit. Le newuser.save est le premier op asynchrone mangouste qui se produit, mais il se produit bien après que la promesse est que lib soit définie pour la connexion.

La bibliothèque promise doit-elle être définie dans chaque fichier qui accède aux fonctions asynchrones de mangouste, par opposition à la définition de la bibliothèque promise une seule fois lorsque la connexion de mangouste est configurée?

@ stevenelson74708 J'ai eu le même problème. Je pensais l'avoir résolu avec: mongoose.Promise = global.Promise dans le point d'entrée de l'application. Il semble que vous en ayez besoin dans chaque fichier qui accède aux promesses de la mangouste. Assez ennuyeux. Il suffit de définir la configuration de la mangouste dans un fichier séparé, de l'exporter et de l'importer là où c'est nécessaire.

J'ai également remarqué récemment que je recevais cet avertissement, bien que j'aie défini la promesse dans mon fichier app.js. J'ai essayé d'utiliser à la fois native et bluebird avec les mêmes résultats.

// FILE: app.js
import bluebird from 'bluebird';
import mongoose from 'mongoose';

// use bluebird as default promise library
mongoose.Promise = bluebird;

J'importe la mangouste dans quelques-uns de mes modèles et je les utilise dans des méthodes de schéma. J'ai résolu le problème en définissant la bibliothèque de promesses dans chaque fichier qui importe la mangouste seule (voir le TODO dans l'extrait ci-dessous). Je ne me souviens pas avoir vu l'avertissement il y a quelques mois avec une structure de code similaire.

// FILE: SessionModel.js
import bluebird from 'bluebird';
import mongoose from 'mongoose';

// TODO: remove this redundant bit of code
// use bluebird as default promise library
mongoose.Promise = bluebird;

SessionSchema.methods.getUser = function(callback) {
  return mongoose.model('User').findById(this.user, callback);
};

@mcfarljw Vous

// config.js
const bluebird = require('bluebird');
const mongoose = require('mongoose');
mongoose.Promise = bluebird;
mongoose.connect('mongodb://localhost:27017/myApp)
module.exports = { mongoose }

// SessionModel.js
const { mongoose } = require('./config')

SessionSchema.methods.getUser = function(callback) {
  return mongoose.model('User').findById(this.user, callback);
};

De cette façon, vous n'aurez pas à écrire "mongoose.Promise = bluebird" plusieurs fois :)

Dans ma situation, recevait l'avertissement de dépréciation lors de l'action sur les sous-documents en utilisant la syntaxe .then() , mais pas sur les documents parents. Donc, l'avertissement occasionnel m'a fait penser que j'avais des problèmes de syntaxe avec les documents enfants, mais c'était en fait l'absence de ligne de promesse dans le fichier modèle, comme d'autres l'ont conseillé ci-dessus.

Oui, il semble que la définition de mongoose.Promise dans les fichiers de schéma où mongoose.model est exporté élimine l'avertissement dans les versions 4.8 et ultérieures de la mangouste.

Ouais, passer le singleton mangouste comme votre propre exportation mutée permettrait de contourner le problème, mais c'est certes un peu un hack.

À ce stade, je ne sais pas exactement quelle est la configuration / configuration "appropriée" de la mangouste pour éviter l'avertissement. Cet avertissement est-il un problème avec les versions actuelles de la mangouste ou est-ce le signe d'une mauvaise configuration de la mangouste? Existe-t-il une configuration de mangouste recommandée qui empêchera l'avertissement? Encore une fois, cet avertissement ne commence à apparaître qu'avec la version 4.8.0 de mangouste.

J'ai le même problème sur la configuration de la mangouste mondiale.

J'ai tracé, il peut définir correctement le bluebird sur promise_provider, mais lorsque j'essaye de récupérer la promesse, il renvoie l'ES6.

Je viens de passer et d'ajouter

mongoose.Promise = global.Promise

immédiatement après l'exigence / l'importation de mangouste dans chaque fichier source qui l'utilise, et bien que ce soit exagéré, cela n'a pris que très peu de réflexion et pas beaucoup de temps à faire, et cela l'a résolu complètement. Donc, pas vraiment la plus grosse des affaires.

Cela remet en question ma connaissance, certes limitée, de la manière dont le travail est requis et importé. J'avais l'impression que peu importe le nombre de fois où vous avez besoin de quelque chose, vous obtenez toujours la même instance, donc la promesse une fois devrait suffire, pensez-vous. C'est donc un peu contre-intuitif.

salut
J'ai un exemple de code qui cause le problème

import mongoose from 'mongoose';

mongoose.Promise = Promise;

import Test from './test.model';

mongoose.connect(uri, options);
mongoose.connection.on('error', err => console.error(`MongoDB connection error: ${err}`));

Test.create({ name: 'Hi'})
  .then(() => Test.findOne({}))
  .then(res => res.save())
  .then(() => console.log('Done'));

(test.model est juste un modèle simple avec un champ pour le nom)

Pour une raison quelconque, le problème apparaît pour la première fois lors de l'exécution de res.save(); . Sans cela, tout fonctionne comme d'habitude.

Je crois que ce problème vient du fait que Babel change l'ordre lors de la transpilation du code. Lorsque Babel transpile, il déplace toutes les importations vers le haut. Ainsi, lorsque le test.model est importé dans mon exemple, la bibliothèque Promise est toujours attribuée à mpromise.

J'utilise Node.js 6.10.0 et Mongoose 4.8.5 et j'ai ce problème.

Je sauvegarde mon objet utilisateur:

var newUser = User({
    login       : 'john',
    password    : 'secret',
    firstname   : 'John',
    lastname    : 'Doe',
    avatar      : 'avatar.png'
});

newUser.save(function(err){
    if(err) throw err;

    console.log('User created !');
});

Et j'ai la même erreur. J'ai essayé de cette façon:

mongoose.Promise = require('bluebird');
mongoose.connect(conf.dbpath);

Et de cette façon:

mongoose.Promise = global.Promise;
mongoose.connect(conf.dbpath);

Mais j'ai à nouveau l'avertissement obsolète. Comment puis-je réparer cela ?

Comment corriger l'avertissement de dépréciation:

var mongoose = require('mongoose');

mongoose.Promise = global.Promise;
var schema = new mongoose.Schema({
 // definition
}, {
 // options
});

module.exports = mongoose.model('foobar', schema);

Ouais ça marche si je mets ça dans mon modèle. Nous devons donc initier mongoose.Promise à l'intérieur de chaque modèle.

Je pense que @ stevenelson74708 a un excellent point en disant At this point it's unclear to me as to exactly what the "proper" mongoose setup/configuration to avoid the warning is.

Oui, une solution serait de parcourir tous les fichiers de modèle de mangouste et d'ajouter mongoose.Promise = global.Promise après l'importation, mais comme ce problème n'est apparu que récemment, il serait bon d'obtenir une réponse plus concrète quant aux intentions. ou les causes derrière cela. Je ne sais pas à ce stade s'il s'agit d'un problème causé par la mangouste, le babel ou une combinaison des deux.

Probablement une dupe de # 5030. Essayez de passer à> = 4.9.1.

Pour mémoire, la solution @bricss a plutôt bien fonctionné pour moi :)

Au début, la solution vient de @ steve-p-com. Pas de @bricss.
@ vkarpov15 même avertissement avec 4.9.3.
@stillesjo ce n'est rien avec babel. L'avertissement se produit également sur nativ sans Babel sur Node 7.8.0.

Je n'ai aucun avertissement depuis la version 4.9.3 🌷

Même lorsque nous définissons mongoose.Promise = global.Promise; sur chaque modèle, je pense que ce n'est pas une solution idéale, non? Pourquoi ne pas utiliser global.Promise par défaut et laisser les utilisateurs changer s'ils le souhaitent?

Test unitaire de mes modèles. Je dois l'inclure pour que nous ne voyions pas l'avertissement lors de l'exécution de tests localement ou sur CI.
J'utilise "mongoose": "4.10.4" avec le nœud v7.10.0

@lesterzone

Juste pour ajouter à cela une solution DRY, configurez-la là où vous initialisez la connexion avec la base de données au lieu de la définir à l'intérieur de chaque modèle.

const mongoose = require('mongoose');
mongoose.Promise = global.Promise;
mongoose.connect('mongodb://...');

semble fonctionner

Cela ne fonctionnera pas nécessairement pour tout le monde. Cela dépend de la structure de votre code. Si, par exemple, le fichier avec le code de connexion nécessite des modèles provenant de fichiers source séparés, la manière dont require works signifie que ces fichiers source seront chargés avant que la promesse globale ait été définie dans le fichier contenant le code de connexion. Ces modèles continueront à utiliser la valeur par défaut pour la promesse. La voie la plus sûre consiste simplement à définir la promesse globale dans chaque fichier source qui nécessite mangouste.

cela fonctionne pour moi
`` ``
importer de la mangouste de «mangouste»;
importer la configuration depuis './config';
importer bluebird depuis 'bluebird';

rappel par défaut d'exportation => {
mangouste.Promise = oiseau bleu;
// se connecte à la base de données depuis l'instance de la base de données dans le fichier de configuration
let db = mongoose.connect (config.mongoUrl, {useMongoClient: true});
rappel (db);
}
`` ``

C'est comme ça que je le fais.

var colors = require('colors');
var mongo = require('mongodb');
var mongoose = require('mongoose');
mongoose.Promise = require('bluebird');

var db = mongoose.connection;

mongoose.connect('mongodb://localhost:27017/db', { useMongoClient: true })
.then(function(){
  console.log(" Connected to dbName ".green);

}).catch(err => console.error(err));

Vous devez utiliser la fonction .create qui vient avec mangouste plutôt que .save,
J'ai changé le mien et ça résout le problème

Je suis sur 4.13.9 et cela existe toujours. @ La solution