Mongoose: Aviso de descontinuação: Mongoose: mpromise (biblioteca de promessa padrão do mongoose) foi descontinuado com 4.8.0 e 4.8.1

Você pode colar o código que realmente produz o erro? Esse código não funcionará porque você ainda não usou uma promessa (a menos que esteja dizendo que o snippet de conexão postado produz o aviso?)

Não, o snippet de conexão não produz o aviso. O seguinte snippet de salvamento de novo usuário é o código que produz o aviso, mas apenas a primeira vez que o código é executado depois que o aplicativo foi iniciado (novamente, o aviso não ocorre nas versões do mongoose 4.7.9 e anteriores):

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

O esquema do usuário é o seguinte:

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

Posso confirmar o mesmo problema com mongoose v4.8.1 e 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 obrigado pelo snippet, mas o esquema em si provavelmente não é o problema. O que estou procurando é como o esquema é importado e usado em relação a quando a conexão é aberta / o construtor mongoose Promise é definido.

O esquema é exportado do arquivo de esquema onde é declarado da seguinte maneira:

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

e o esquema é importado para o arquivo, é usado, onde newuser.save é chamado da seguinte maneira:

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

O snippet de conexão (onde a conexão é aberta e o construtor mongoose Promise está definido) mostrado na minha primeira postagem ocorre no arquivo app.js que é executado na inicialização durante a inicialização do aplicativo.

O snippet newuser.save mostrado na minha segunda postagem é executado a partir do arquivo onde o esquema do usuário é importado e o newuser.save é executado quando um usuário interage com o aplicativo e faz com que uma rota específica seja executada, o que ocorre bem após a inicialização do aplicativo foi completado.

O aviso ocorre apenas na primeira vez que o código newuser.save é executado após a inicialização do aplicativo, embora o mesmo código newuser.save seja executado muitas vezes após a inicialização, e o aviso não parece ocorrer com as versões 4.7.9 e anteriores do mongoose.

@ stevenelson74708 vou precisar ver todos os componentes que desempenham uma função na inicialização do seu aplicativo. Muitas pessoas abriram questões recentemente sobre isso, e cada uma delas resultou da configuração incorreta do construtor de promessa, então meu palpite é que você está fazendo algo errado na ordem em que definiu mongoose.Promise .

Existe alguma maneira de ver seu código?

Abaixo está todo o código (na ordem exata) na inicialização do app.js que está relacionado à configuração do mongoose, incluindo a configuração do mongoose.Promise. O aviso não ocorre quando o código de inicialização é executado. O aviso ocorre apenas na primeira vez que o código newuser.save (mostrado em meu post anterior) é executado depois que o aplicativo foi inicializado. Existem chamadas findOneAndUpdate que são executadas antes do salvamento que não causam o aviso, então parece que é apenas a funcionalidade de salvamento que causa o aviso.

A configuração do mangusto é uma das primeiras coisas que ocorre na inicialização. A configuração do mongoose deve ocorrer mais tarde na inicialização, como após a funcionalidade createServer?

Novamente, o aviso não parece ocorrer nas versões 4.7.9 e anteriores do mangusto:

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

Não, a configuração pode vir primeiro. Este arquivo é o ponto de entrada para seu aplicativo ou existe um arquivo que o precede?

O arquivo app.js é o ponto de entrada para o aplicativo. O aplicativo pode ser chamado digitando node app.js na linha de comando.

Eu tenho o mesmo problema com o mongoose 4.8.1 e o nó 7.5.0. Também estou usando o Typescript e tentando conectar o Bluebird para promessas. Descobri que o aviso desaparece se eu adicionar este código:

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

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

em CADA arquivo que importa algo de 'mangusto'. Então, eu preciso fazer isso em cada arquivo de modelo (arquivo onde eu defino meu esquema) em vez de apenas no arquivo de ponto 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');
});

Não imprime este aviso, então há outra coisa.

@vladimirdjurdjevic isso significa que em algum lugar você está usando uma operação assíncrona do mongoose antes de definir a lib de promessa. Eu não uso TS, então não sei se isso tem alguma coisa a ver com isso.

Eu defino a promessa lib conforme mostrado acima no arquivo app.js que é o ponto de entrada do aplicativo e, então, quando o primeiro newuser.save é executado (muito depois de a promessa lib ter sido definida) conforme mostrado acima, o aviso ocorre. O newuser.save é a primeira operação assíncrona mongoose que ocorre, mas ocorre bem depois que a promessa de lib é definida para a conexão.

A promessa lib deve ser definida em cada arquivo que acessa as funções assíncronas do mongoose, em vez de definir a promessa lib apenas uma vez quando a conexão mongoose é configurada?

@ stevenelson74708 Eu tive o mesmo problema. Achei que tivesse resolvido com: mongoose.Promise = global.Promise no ponto de entrada do aplicativo. Parece que você precisa disso em todos os arquivos que acessam as promessas do mangusto. Muito chato. Basta definir a configuração do mangusto em um arquivo separado, exportá-lo e importá-lo sempre que necessário.

Também notei recentemente que estou recebendo este aviso, embora tenha definido a promessa em meu arquivo app.js. Eu tentei usar o nativo e o bluebird com os mesmos resultados.

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

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

Estou importando o mangusto para alguns dos meus modelos e usando-os em métodos de esquema. Resolvi o problema configurando a biblioteca de promessas em todos os arquivos que importam o mongoose por conta própria (consulte TODO no trecho abaixo). Não me lembro de ter visto o aviso alguns meses atrás devido a uma estrutura de código semelhante.

// 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 É melhor você fazer algo assim:

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

Dessa forma, você não terá que escrever "mongoose.Promise = bluebird" várias vezes :)

Na minha situação, recebia o aviso de descontinuação ao agir em subdocumentos usando a sintaxe .then() , mas não em documentos-pai. Portanto, o aviso ocasional me fez pensar que eu tinha problemas de sintaxe ao lidar com documentos filhos, mas era na verdade a falta de linha de promessa no arquivo de modelo, como outros aconselharam acima.

Sim, parece que definir o mongoose.Promise nos arquivos de esquema em que mongoose.model é exportado elimina o aviso nas versões do mongoose 4.8 e posteriores.

Sim, passar o singleton do mangusto como sua própria exportação mutante contornaria o problema, mas é admitidamente um hack.

Neste ponto, não está claro para mim exatamente qual é a configuração / configuração "adequada" do mangusto para evitar o aviso. Este aviso é um problema com as versões atuais do mangusto ou é uma indicação de uma configuração inadequada do mangusto? Existe uma configuração de mangusto recomendada que evite o aviso? Novamente, esse aviso só começa a ocorrer com o mongoose versão 4.8.0.

Eu tenho o mesmo problema em definir o mangusto global.

Eu rastreei, ele pode definir o bluebird corretamente para a promessa_provedor, mas quando eu tentei voltar a promessa, ele retornará o ES6.

Eu apenas passei e adicionei

mongoose.Promise = global.Promise

imediatamente após a solicitação / importação do mongoose em cada arquivo de origem que o usa, e embora seja um exagero, demorou muito pouco para pensar e não muito tempo para fazer, e ele corrigiu completamente. Portanto, não é realmente o maior dos negócios.

Isso desafia meu conhecimento reconhecidamente limitado de como exigir e importar trabalho. Tive a impressão de que, não importa quantas vezes você exija algo, sempre obtém a mesma instância, portanto, definir a promessa uma vez deve ser o suficiente, você pensaria. Portanto, é um pouco contra-intuitivo.

Oi
Eu tenho algum código de exemplo que causa o 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 é apenas um modelo simples com um campo para nome)

Por alguma razão, o problema aparece pela primeira vez ao fazer res.save(); . Sem ele, tudo funciona normalmente.

Acredito que esse problema venha do babel alterar a ordem ao transpilar o código. Quando o babel transpila, ele move todas as importações para o topo. Portanto, quando o test.model é importado em meu exemplo, a biblioteca Promise ainda é atribuída a mpromise.

Estou usando o Node.js 6.10.0 e o Mongoose 4.8.5 e resolvi esse problema.

Eu salvo meu objeto de usuário:

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

E eu tenho o mesmo erro. Eu tentei desta forma:

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

E desta maneira :

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

Mas tenho novamente o aviso obsoleto. Como posso consertar isso ?

Aviso de suspensão de uso:

var mongoose = require('mongoose');

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

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

Sim, funciona se eu colocar isso no meu modelo. Portanto, temos que iniciar o mongoose.Promise dentro de cada modelo.

Acho que @ stevenelson74708 tem um excelente ponto ao dizer At this point it's unclear to me as to exactly what the "proper" mongoose setup/configuration to avoid the warning is.

Sim, uma solução seria voltar a todos os arquivos de modelo do mangusto e adicionar mongoose.Promise = global.Promise após a importação, mas como esse problema só surgiu recentemente, seria bom obter uma resposta mais concreta sobre as intenções ou causas por trás dele. Não tenho certeza se é um problema causado por mangusto, babel ou uma combinação dos dois.

Provavelmente um idiota de # 5030. Tente atualizar para> = 4.9.1.

Só para @bricss funcionou muito bem para mim :)

A princípio, a solução vem de @steve-p-com. Não de @bricss.
@ vkarpov15 mesmo aviso com 4.9.3.
@stillesjo não é nada com a babel. O aviso ocorre também no nativ sem Babel no nó 7.8.0.

Não tenho nenhum aviso desde a versão 4.9.3 🌷

Mesmo quando definimos mongoose.Promise = global.Promise; em cada modelo, acho que não é uma solução _ideal_, certo? Por que não usar global.Promise como padrão e permitir que os usuários mudem se quiserem?

Teste de unidade em meus modelos. Tenho que incluí-lo para que não vejamos o aviso ao executar testes localmente ou em CI.
Estou usando "mongoose": "4.10.4" com o nó v7.10.0

@lesterzone

Apenas para adicionar a isso uma solução DRY, configure onde você inicializa a conexão com o banco de dados ao invés de configurar dentro de cada modelo.

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

parece funcionar

Porém, isso não funcionará necessariamente para todos. Depende da sua estrutura de código. Se, por exemplo, o arquivo com o código de conexão requer modelos de arquivos de origem separados, a maneira como o require funciona significa que esses arquivos de origem serão carregados antes que a promessa global tenha sido definida no arquivo que contém o código de conexão. Esses modelos continuarão a usar o valor padrão para a promessa. O caminho seguro é simplesmente definir a promessa global em cada arquivo de origem que requer o mangusto.

isso funciona para mim
`` ``
importar mangusto de 'mangusto';
importar configuração de './config';
importar bluebird de 'bluebird';

exportar callback padrão => {
mongoose.Promise = bluebird;
// conectar ao banco de dados a partir da instância do banco de dados no arquivo de configuração
let db = mongoose.connect (config.mongoUrl, {useMongoClient: true});
retorno de chamada (db);
}
`` ``

É assim que estou fazendo.

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

Você deve usar a função .create que vem com o mongoose em vez de .save,
Eu mudei o meu e resolve o problema

Estou no 4.13.9 e isso ainda existe. A solução