Mongoose: DeprecationWarning: Mongoose: mpromise (la biblioteca de promesas predeterminada de mangoose) está en desuso con 4.8.0 y 4.8.1

¿Puedes pegar el código que realmente produce el error? Ese código no lo hará porque aún no ha usado una promesa (a menos que esté diciendo que el fragmento de conexión que publicó produce la advertencia).

No, el fragmento de conexión no genera la advertencia. El siguiente fragmento de guardado de newuser es el código que produce la advertencia, pero solo la primera vez que se ejecuta el código después de que se haya iniciado la aplicación (nuevamente, la advertencia no ocurre en las versiones 4.7.9 y anteriores de mangosta):

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

El esquema de usuario es el siguiente:

`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 ]
  });`

Puedo confirmar el mismo problema con mongoose v4.8.1 y 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 gracias por el fragmento, pero el esquema en sí probablemente no es el problema. Lo que estoy buscando más es cómo se importa y se usa el esquema en relación con cuando se abre la conexión / se establece el constructor de Mongoose Promise.

El esquema se exporta desde el archivo de esquema donde se declara de la siguiente manera:

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

y el esquema se importa en el archivo que se usa donde newuser.save se llama de la siguiente manera:

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

El fragmento de conexión (donde la conexión está abierta y el constructor Mongoose Promise está configurado) que se muestra en mi primera publicación ocurre en el archivo app.js que se ejecuta en la inicialización durante el inicio de la aplicación.

El fragmento de newuser.save que se muestra en mi segunda publicación se ejecuta desde el archivo donde se importa el esquema de usuario y el newuser.save se ejecuta cuando un usuario interactúa con la aplicación y hace que se ejecute una ruta específica, que es mucho después de la inicialización de la aplicación se ha completado.

La advertencia ocurre solo la primera vez que se ejecuta el código newuser.save después del inicio de la aplicación, aunque el mismo código newuser.save se ejecuta muchas veces después del inicio, y la advertencia no parece ocurrir con las versiones 4.7.9 y anteriores de Mongoose.

@ stevenelson74708 voy a necesitar ver todos los componentes que juegan un papel en el inicio de su aplicación. Muchas personas han abierto problemas recientemente con respecto a esto, y todos se han derivado de configurar incorrectamente el constructor de promesas, por lo que supongo que estás haciendo algo mal en el orden en que estableciste mongoose.Promise .

¿Hay alguna forma de que pueda ver su código?

A continuación se muestra todo el código (en orden exacto) en la inicialización de app.js que está relacionado con la configuración de mongoose, incluida la configuración de mongoose.Promise. La advertencia no ocurre cuando se ejecuta el código de inicialización. La advertencia solo ocurre la primera vez que el código newuser.save (mostrar en mi publicación anterior) se ejecuta después de que se haya inicializado la aplicación. Hay llamadas findOneAndUpdate que se ejecutan antes del guardado que no causan la advertencia, por lo que parece que es solo la funcionalidad de guardado la que causa la advertencia.

La configuración de la mangosta es una de las primeras cosas que ocurre en la inicialización. ¿Debería producirse la configuración de mangosta más adelante en la inicialización, como después de la funcionalidad createServer?

Nuevamente, la advertencia no parece ocurrir en las versiones 4.7.9 y anteriores de mangosta:

`// 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);
});`

No, la configuración puede ser lo primero. ¿Es este archivo el punto de entrada para su aplicación o hay un archivo que lo precede?

El archivo app.js es el punto de entrada para la aplicación. La aplicación se puede invocar escribiendo node app.js en la línea de comando.

Tengo el mismo problema con la mangosta 4.8.1 y el nodo 7.5.0. También estoy usando TypeScript y trato de conectar Bluebird para las promesas. Descubrí que la advertencia desaparece si agrego este código:

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

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

en CADA archivo que importe algo de 'mangosta'. Así que necesito hacer eso en cada archivo de modelo (archivo donde defino mi esquema) en lugar de solo en el archivo de punto de entrada.

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

No imprime esta advertencia, así que hay algo más.

@vladimirdjurdjevic, esto significa que en algún lugar estás usando una operación asíncrona de mangosta antes de establecer la promesa lib. No uso TS, así que no sé si eso tiene algo que ver.

Configuré la biblioteca de promesas como se muestra arriba en el archivo app.js, que es el punto de entrada de la aplicación, y luego, cuando se realiza el primer newuser.save (mucho después de que se haya establecido la biblioteca de promesas) como se muestra arriba, se produce la advertencia. El newuser.save es la primera operación asíncrona de mangosta que ocurre, pero ocurre mucho después de que se establece la promesa lib para la conexión.

¿Se debe establecer la biblioteca de promesa en cada archivo que accede a las funciones asíncronas de mongoose en lugar de establecer la biblioteca de promesa solo una vez cuando se configura la conexión de mangosta?

@ stevenelson74708 Tuve el mismo problema. Pensé que lo resolví con: mongoose.Promise = global.Promise en el punto de entrada de la aplicación. Parece que lo necesita en todos los archivos que acceden a las promesas de mangosta. Bastante molesto. Simplemente establezca la configuración de mangosta en un archivo separado, expórtelo e impórtelo donde sea necesario.

También noté recientemente que recibo esta advertencia, aunque establecí la promesa en mi archivo app.js. Intenté usar tanto el nativo como el bluebird con los mismos resultados.

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

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

Estoy importando mangosta en algunos de mis modelos y utilizándolos en métodos de esquema. Resolví el problema configurando la biblioteca de promesas en cada archivo que importa mangosta por sí solo (vea TODO en el fragmento a continuación). No recuerdo haber visto la advertencia hace unos meses dada una estructura de código similar.

// 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 Es mejor que hagas algo como esto:

// 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 esa manera, no tendrás que escribir "mongoose.Promise = bluebird" varias veces :)

En mi situación, recibía la advertencia de desaprobación al actuar en subdocumentos usando la sintaxis .then() , pero no en los documentos principales. Entonces, la advertencia ocasional me hizo pensar que tenía problemas de sintaxis al tratar con documentos para niños, pero de hecho fue la falta de una línea de promesa en el archivo del modelo, como otros han aconsejado anteriormente.

Sí, parece que la configuración de mongoose.Promise en los archivos de esquema donde se exporta mongoose.model elimina la advertencia en las versiones 4.8 y posteriores de mongoose.

Sí, pasar el singleton de mangosta como su propia exportación mutada solucionaría el problema, pero es cierto que es un poco complicado.

En este punto, no me queda claro cuál es exactamente la configuración "adecuada" de la mangosta para evitar la advertencia. ¿Esta advertencia es un problema con las versiones actuales de mangosta o es una indicación de una configuración incorrecta de mangosta? ¿Existe una configuración de mangosta recomendada que evite la advertencia? Nuevamente, esta advertencia solo comienza a ocurrir con la versión 4.8.0 de mangosta.

Tengo el mismo problema al configurar la mangosta global.

He rastreado, puede configurar el bluebird correctamente en promise_provider pero cuando intenté recuperar la promesa, devolverá el ES6.

Solo lo revisé y agregué

mongoose.Promise = global.Promise

inmediatamente después del requerimiento / importación de mangosta en cada archivo fuente que lo usa, y aunque eso es excesivo, tomó muy poco pensar y no mucho tiempo, y lo solucionó por completo. Entonces, no es realmente la mayor de las ofertas.

Desafía mi reconocido conocimiento limitado de cómo requerir e importar el trabajo. Tenía la impresión de que no importa cuántas veces necesite algo, siempre obtiene la misma instancia, por lo que establecer la promesa una vez debería ser suficiente, pensaría. Entonces es un poco contraintuitivo.

Hola
Tengo un código de ejemplo que causa el problema.

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 es solo un modelo simple con un campo para el nombre)

Por alguna razón, el problema aparece por primera vez al hacer res.save(); . Sin él, todo funciona como de costumbre.

Creo que este problema proviene de que babel cambia el orden al transpilar el código. Cuando babel se transpila, mueve todas las importaciones a la parte superior. Entonces, cuando se importa test.model en mi ejemplo, la biblioteca Promise todavía está asignada a mpromise.

Estoy usando Node.js 6.10.0 y Mongoose 4.8.5 y tengo este problema.

Guardo mi objeto de usuario:

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

Y tengo el mismo error. Intenté de esta manera:

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

Y de esta manera:

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

Pero tengo nuevamente la advertencia en desuso. Cómo puedo arreglar esto ?

Cómo corregir la advertencia de obsolescencia:

var mongoose = require('mongoose');

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

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

Sí, funciona si pongo esto en mi modelo. Así que tenemos que iniciar mangosta. Promesa dentro de cada modelo.

Creo que @ stevenelson74708 tiene un punto excelente al decir At this point it's unclear to me as to exactly what the "proper" mongoose setup/configuration to avoid the warning is.

Sí, una solución sería volver a revisar todos los archivos del modelo de mangosta y agregar mongoose.Promise = global.Promise después de la importación, pero dado que este problema ha surgido recientemente, sería bueno obtener una respuesta más concreta sobre las intenciones. o causas detrás de él. En este punto, no estoy seguro de si se trata de un problema causado por la mangosta, la babel o una combinación de los dos.

Probablemente una víctima de # 5030. Intente actualizar a> = 4.9.1.

Para que conste, la solución de @bricss funcionó bastante bien para mí :)

Al principio, la solución proviene de @ steve-p-com. No de @bricss.
@ vkarpov15 misma advertencia con 4.9.3.
@stillesjo no es nada con babel. La advertencia también ocurre en nativ sin Babel en el nodo 7.8.0.

No tengo ninguna advertencia desde la versión 4.9.3 🌷

Incluso cuando configuramos mongoose.Promise = global.Promise; en cada modelo, creo que no es una solución _ideal_, ¿verdad? ¿Por qué no usar global.Promise forma predeterminada y permitir que los usuarios cambien si así lo desean?

Prueba unitaria de mis modelos. Tengo que incluirlo para que no veamos la advertencia al ejecutar pruebas localmente o en CI.
Estoy usando "mongoose": "4.10.4" con el nodo v7.10.0

@lesterzone

Solo para agregar a esto una solución DRY, configúrela donde inicialice la conexión con la base de datos en lugar de configurarla dentro de cada modelo.

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

parece funcionar

Sin embargo, eso no funcionará necesariamente para todos. Depende de la estructura de su código. Si, por ejemplo, el archivo con el código de conexión requiere modelos de archivos de origen separados, la forma en que require funciona significa que esos archivos de origen se cargarán antes de que se haya establecido la promesa global en el archivo que contiene el código de conexión. Esos modelos seguirán usando el valor predeterminado para la promesa. La ruta segura es simplemente establecer la promesa global en cada archivo fuente que requiera mangosta.

esto funciona para mi
`` ``
importar mangosta de 'mangosta';
importar la configuración desde './config';
importar bluebird de 'bluebird';

exportar devolución de llamada predeterminada => {
mangosta.Promesa = pájaro azul;
// conectarse a la base de datos desde la instancia de la base de datos en el archivo de configuración
let db = mongoose.connect (config.mongoUrl, {useMongoClient: true});
devolución de llamada (db);
}
`` ``

Así es como lo estoy haciendo.

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

Tienes que usar la función .create que viene con mangosta en lugar de .save,
Cambié el mío y soluciona el problema

Estoy en 4.13.9 y esto todavía existe. La solución