Mongoose: Aviso de suspensão de uso

Hmm você está usando promessas em algum lugar? Você não deve receber esse aviso a menos que use promessas ...

não, não estou usando promessas

Acabei de começar a ter esse problema também. Não usando promessas que eu saiba!

Eu resolvi esse aviso fazendo

mongoose.Promise = global.Promise;

Logo antes de chamar mongoose.connect

// connect to mongo function
core.connect = function connect(opts) {
  mongoose.Promise = global.Promise;
  mongoose.connect(`mongodb://${opts.server}:${opts.port}/${opts.db}`);
  return mongoose.connection;
};

Sim, este aviso deve dizer para você alterar a lib de promessa padrão do mangusto se você estiver usando promessas, mas isso não deve acontecer a menos que você chame .then em algum lugar

Estou conseguindo, mas só estou conseguindo onde salvo um objeto, modifique-o no retorno de chamada e salve novamente

Eu tentei a abordagem @SAudelOG para atribuir uma promessa ao mangusto antes da conexão do mangusto, mas ainda estou recebendo esse erro

Estou usando funções assíncronas es7 e meu código é bloqueado quando tento Model.findOne({})

A solução @SAudelOG fornece funciona. Como @IrishAdo , estou obtendo isso apenas ao salvar um objeto também. Talvez seja por causa de um dos plugins do mangusto que estou usando usando a biblioteca de promessas do Bluebird.

Aqui está uma lista de dependências que estou usando

  "dependencies": {
    "async": "^2.0.0-rc.6",
    "body-parser": "^1.15.0",
    "bower": "^1.7.7",
    "compression": "^1.6.1",
    "connect-mongo": "^1.2.1",
    "consolidate": "^0.14.1",
    "cookie-parser": "^1.4.3",
    "express": "^4.13.4",
    "express-jwt": "^3.4.0",
    "express-session": "^1.13.0",
    "express-validator": "^2.20.8",
    "faker": "^3.1.0",
    "http-errors": "^1.5.0",
    "jsonwebtoken": "^7.0.1",
    "lodash": "^4.13.1",
    "method-override": "^2.3.5",
    "mongoose": "^4.4.3",
    "mongoose-beautiful-unique-validation": "^3.0.0",
    "mongoose-delete": "^0.3.3",
    "mongoose-validator": "^1.2.5",
    "morgan": "^1.6.1",
    "passport": "^0.3.2",
    "passport-local": "^1.0.0",
    "swig": "^1.4.2"
  }

Não estou usando plugins nem promessas e recebendo este aviso também (em [email protected]).

Executando meu aplicativo com "--trace-deprecation" eu tenho:

Trace: Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead:
http://mongoosejs.com/docs/promises.html
    at Object.exports._printDeprecationMessage (internal/util.js:30:13)
    at Promise.deprecated [as then] (internal/util.js:54:22)
    at fnWrapper (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:188:11)
    at EmbeddedDocument.Object.defineProperty.value.fn (.\node_modules\mongoose\lib\schema.js:219:11)
    at _next (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:62:30)
    at fnWrapper (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:186:18)
    at EmbeddedDocument.Object.defineProperty.value.fn (.\node_modules\mongoose\lib\schema.js:173:18)
    at EmbeddedDocument._next (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:62:30)
    at EmbeddedDocument.proto.(anonymous function) [as $__original_save] (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:108:20)
    at .\node_modules\mongoose\lib\document.js:1917:24
    at new Promise.ES6 (.\node_modules\mongoose\lib\promise.js:45:3)
    at EmbeddedDocument.wrappedPointCut [as save] (.\node_modules\mongoose\lib\document.js:1893:14)
    at async.each.i (.\node_modules\mongoose\lib\schema.js:225:18)
    at .\node_modules\async\lib\async.js:181:20
    at Object.async.forEachOf.async.eachOf (.\node_modules\async\lib\async.js:233:13)
    at Object.async.forEach.async.each (.\node_modules\async\lib\async.js:209:22)
    at model.Object.defineProperty.value.fn (.\node_modules\mongoose\lib\schema.js:223:15)
    at _next (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:62:30)
    at fnWrapper (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:186:18)
    at .\node_modules\mongoose\lib\schema.js:200:17
    at .\node_modules\mongoose\node_modules\kareem\index.js:127:16
    at nextTickCallbackWith0Args (node.js:420:9)
    at process._tickDomainCallback (node.js:390:13)

Eu tenho o mesmo problema, se for alguma ajuda, ele é acionado especificamente quando tento criar documentos que possuem uma matriz de subdocumentos dentro deles, algo como:

var data = {
  field: 'value',
  another_field: [{subdocfield1: 'value', subdocfield2: 'value'}]
} 

mySchema.create(data, cb)

Isso não ocorre com outras coleções que não possuem subdocs, nem acontece se eu emitir a instrução create sem os dados do subdoc, assim:

var data = {
  field: 'value'
} 

mySchema.create(data, cb)

_Nota:_ mongoose.Promise = global.Promise resolveu o problema de aviso para mim embora

Experimentando o mesmo aviso de depreciação quando uso remove() em um documento. Não estou usando promessas aqui ou em qualquer outro lugar no meu código.

Acabei de receber esse erro ao usar Model.create(objects, callback); , talvez essa correção ainda não tenha sido publicada no npm?

Obtendo isso, feliz em lê-lo não é alarmante. Vou manter um olhar mais atento sobre isso para ajudar a depurar quando isso acontecer.

Obtendo isso também, e não estou usando promessas de mangusto em nenhum lugar.

Consegui rastreá-lo de volta para uma chamada model.save dentro de um retorno de chamada da biblioteca on-headers , e o modelo foi criado fora do retorno de chamada, antes de ser chamado, caso ajude alguém. Colocar a criação do modelo e a chamada de salvamento no retorno de chamada não faz diferença.

Enfrentando esse problema no nó v4.4.6, enquanto na v4.4.2 isso parece funcionar

Exemplo de código @SKatiyar por favor

mesmo comigo, recebendo esta mensagem depois de invocar o método save() , o suficiente para eu me importar

Isso funciona! Antes de mongoose.connect(MONGO_URI); adicione mongoose.Promise = global.Promise;

O código a seguir é suficiente para reproduzir no meu final:

const mongoose = require('mongoose');
const schema = new mongoose.Schema({
  data: { type: Number }
});
const Model = mongoose.model('schema', schema);
mongoose.connect('mongodb://127.0.0.1:27017/somedatabase');
const newModel = new Model({ data: 1 });
const save = newModel.save(() => {
  console.log('saved model');
});
console.log(typeof save.then); //=> 'function'

O estranho que posso ver aqui é que usar newModel.save(callback) ainda retorna uma promessa (ou estou assumindo que é uma promessa, já que o tipo de .then é 'function' ). Esse é o comportamento esperado?

Seguem minhas versões:
Nó: v6.3.1
Mangusto: v4.5.8

Deixe-me saber se você precisar de qualquer outra informação de mim.

@dvlsg sim, esse é o comportamento esperado atualmente, salvar sempre retornará uma promessa, mesmo que você passe um retorno de chamada

Bem, acho que isso pelo menos explicaria por que as pessoas estão vendo o aviso de promessa mesmo quando não pensam que estão usando promessas.

Isso explica tudo.. Eu sou um pouco paranóico e queria me livrar de todos os avisos 💃

A culpa é minha, sim .save() retorna uma promessa, então isso é esperado, mas ainda assim, o aviso me fez pensar. http://mongoosejs.com/docs/promises.html (só tinha que ler o primeiro parágrafo 🎱)

Portanto .save() retorna uma promessa, mas você não deve receber esse aviso a menos que chame .then() . Se você receber este aviso sem chamar .then() em seu código, isso significa que o mangusto está usando uma promessa em algum lugar onde não deveria, então abra um problema separado com exemplos de código :+1:

IMHO, esta mensagem deve ser um erro ("as coisas não funcionam") em vez de um aviso ("preste atenção, mas deve funcionar"), pois na verdade ela é retornada como erro no retorno de chamada.

Eu me deparei com esse problema e o método aModel.save() não funcionou para colocar no MongoDB. Demorou algum tempo para a causa raiz desse problema. Após aplicar "mongoose.Promise = global.Promise;", deu certo.

Eu estava usando "mangusto": "^4.5.9".

Salvar deve funcionar bem com a lib de promessa padrão, você pode fornecer uma amostra de código?

@vkarpov15

Você tem razão. Acabei de tentar e não consegui recriar do zero o resultado do salvamento de bloqueio com o aviso.

Não tenho certeza se está relacionado a outro código no meu projeto. precisa de algum tempo para verificar. Por favor, ignore antes que eu descubra a causa.

Eu para mim este log aparece no console sempre que eu uso .then(), não importa se é usado com um objeto mangusto ou qualquer outro objeto não relacionado ao mangusto

Então, de acordo com os documentos , estou passando

'use strict';
var Promise = require('bluebird');

// Development specific configuration
// ==================================
module.exports = {
  // MongoDB connection options
  mongo: {
    uri: 'mongodb://localhost/fullstack-dev',
    options: {
      promiseLibrary: Promise
    }
  },
  // .. other config
};

Então no meu arquivo principal fazendo

'use strict';

// Set default node environment to development
process.env.NODE_ENV = process.env.NODE_ENV || 'development';
process.env.BLUEBIRD_DEBUG = 1;
var mongoose = require('mongoose');
var config = require(path.join(__dirname, 'server', 'config', 'environment'));

// Connect to database
var db = mongoose.connect(config.mongo.uri, config.mongo.options);
mongoose.connection.on('error', function(err) {
  console.error('MongoDB connection error: ' + err);
  process.exit(-1);
});

E ainda estou recebendo o aviso de depreciação ao fazer query.exec . Alguma sugestão do que estou fazendo de errado?
[Edit: Adicionando versões de mangusto e bluebird]
Estou usando mangusto ^4.6.1 , bluebird ^3.4.6

Estou recebendo aviso também no mangusto 4.6.1 e no nó 4.4.5

    var mongoose = require('mongoose');
    mongoose.Promise = global.Promise;
    mongoose.connect(dbConfig);
    var connection = mongoose.connection;

@manu29d parece que você não está configurando mongoose.Promise = bluebird

@vkarpov15 Acho que sou. Eu declarei var Promise = no início do script de configuração e depois promiseLibrary: Promise mais tarde. (Veja o primeiro trecho de código nos exemplos)

Além disso, tentei escrever promiseLibrary: require('bluebird') como é fornecido nos documentos.

Não vejo mongoose.Promise = require('bluebird') em nenhum lugar no exemplo de código que você forneceu. var Promise = require('bluebird'); _não_ está certo.

@vkarpov15 Estou me referindo a http://mongoosejs.com/docs/promises.html#promises -for-the-mongodb-driver

Isso ainda é válido? Não tenho tempo para verificar o código se esta opção ( promiseLibrary ) ainda é suportada na configuração ou foi removida.

Definir mongoose.Promise = global.Promise funciona.

mongoose.Promise = global.Promise
antes mongoose.connect funciona para mim também.

Não estou usando promessas e chamando mongoose.Promise = global.Promise antes que a conexão funcione.

@manu29d esses documentos estão corretos, no entanto, se você realmente os ler, verá que a opção promiseLibrary afeta apenas o driver mongodb subjacente, _not_ modelos mongoose.

@zubair-farooqui-10p o script abaixo não aciona o aviso para mim em 4.5.9 ou 4.6.3:

'use strict';

Error.stackTraceLimit = Infinity;

var assert = require('assert');
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/gh4291');
mongoose.set('debug', true);

var connection = mongoose.connection;

É realmente irritante você ter que adicionar essa linha adicional, existe uma maneira de o mangusto corrigi-lo em sua biblioteca interna? Obrigado!

Não em geral, porque a maneira como o mecanismo de troca de lib de promessa do mongoose funciona é bem diferente de como o driver do mongodb é. No mongoose, é apenas uma propriedade que você pode definir no objeto global do mongoose a qualquer momento, enquanto no driver do mongodb é uma opção de conexão, portanto, conexões diferentes podem ter libs de promessa diferentes, mas você só pode definir a lib de promessa quando estiver conectando, não depois. Não é realmente uma prioridade conciliar essas diferenças.

Por que isso acontece ao salvar um documento que possui uma matriz de strings, alguém poderia elaborar

Eu também recebo depois de chamar .createConnecton() . O engraçado é que eu uso Q... MAS! Mas prefiro fazê-lo depois de estabelecer uma conexão, porque eu (e tenho certeza de que todos) prefiro fazê-lo no bloco de declaração var. ou seja

var mongoose = require('mongoose'),
        connection1 = mongoose.createConnection(dbConn1Str),
        connection2 = mongoose.createConnection(dbConn2Str)
;
mongoose.Promise = Q.makePromise;

Em vez disso, para me livrar desse aviso, sou forçado a fazer:

var mongoose = require('mongoose'),
        connection1, connection2
;
mongoose.Promise = Q.makePromise;
connection1 = mongoose.createConnection(dbConn1Str)
connection2 = mongoose.createConnection(dbConn2Str)

Não é grande coisa, mas srsrs...

Sim, esse é o caminho a percorrer. O Mongoose 4.x usará mpromise até que você diga que não.

Eu vejo isso ao usar a chamada find() regular com o auxiliar de consulta. Eu não uso then em lugar nenhum.

BookStore.find().byUsingQueryHelper(1,2,3).lean().exec(function (err, docs) { ... })

Registro:

Mangusto: bookstores.find({ location: { '$near': [ 28.742712943610545, -13.865369983731426 ], '$maxDistance': 0.0012556898446083817 } }, {limit: 10, fields: undefined })

(node:82366) DeprecationWarning: Mongoose: mpromise (biblioteca de promessas padrão do mongoose) está obsoleta, conecte sua própria biblioteca de promessas: http://mongoosejs.com/docs/promises.html

@pronebird infelizmente é assim que exec() funciona internamente, retornos de chamada para exec() realmente passam por uma promessa. Basta fazer mongoose.Promise = global.Promise e você não deve mais receber esse aviso.

@pronebird Recebi o mesmo erro ao postar e descobri que meu esquema tem um valor padrão conforme mostrado abaixo e não corresponde ao meu valor postado abaixo
papel: {
tipo: seqüência de caracteres,
enum: ['Cliente', 'Admin'],
padrão: 'Cliente'
}
Eu posto role:admin e deve ser Admin
espero que esta resposta ajude alguém. obrigado

@Muhammedalbayati Não acho que seu problema tenha algo a ver com esse problema específico? É apenas um aviso emitido pela Mongoose em relação às promessas.

@varunjayaraman você está certo, devo mencionar o seguinte
O aviso
DeprecationWarning: Mongoose: mpromise (biblioteca de promessas padrão do mongoose) está obsoleta, conecte sua própria biblioteca de promessas: http://mongoosejs.com/docs/promises.html

desaparece adicionando mongoose.Promise = global.Promise; antes de conectar ao banco de dados
mongoose.connect('mongodb://localhost:27017/mydb');

@Muhammedalbayati Acho que @vkarpov15 explicou por que esse aviso aparece. O Mongoose usa promessas internamente em exec .

ES6 "yiled" simplesmente não funciona com o método doc.save depois de atualizar o mangusto para v.4.7.7.
Finalmente é só porque mongoose.Promise = global.Promise . Depois que eu removo isso ainda está avisando

Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead:

Acho que o [email protected] tem seu próprio módulo de promessa. Isso está certo??
Alguém o conhece?

É mangusto adicionar uma lib es6-promise.

Questão tão estúpida!

PS: Enfie essa porra de aviso na sua boceta!

como um colega falante de russo, peço desculpas pelo comportamento que este ser inferior demonstrou um desejo de que você não traduza o que está escrito aqui.

@vkarpov15 Eu tentei mongoose.Promise = global.Promise; e mongoose.Promise = require('bluebird'); .

Infelizmente, ainda estou recebendo o aviso de descontinuação.

_Há algo que estou fazendo de errado?_

const mongoose = require('mongoose');

mongoose.Promise = global.Promise;

mongoose.connect('mongodb://localhost/users_test');

mongoose.connection
  .once('open', () => {
    console.log('connectecd to db')
  })
  .on('error', (err) => {
    console.warn('Warning', err)
  });

@protoEvangelium Você está importando o mangusto em outro lugar do seu aplicativo? Esta é a primeira vez que o mangusto está sendo usado ou este arquivo é importado para outro arquivo?

Além disso, qual versão do mongoose /node você está usando?

@varunjayaraman Este arquivo não está sendo importado em nenhum outro lugar. No entanto, estou importando o mangusto no meu arquivo de esquema user.js e, em seguida, usando esse esquema de usuário em alguns dos meus testes.

const mongoose = require('mongoose')
const Schema = mongoose.Schema
const UserSchema = new Schema({
  name: String,
})
const User = mongoose.model('user', UserSchema)
module.exports = User

nó v7.0.0mangusto v4.8.1

@protoEvangelium você está recebendo o aviso em seu aplicativo ou apenas em seus testes?

Eu tive o mesmo problema uma vez - o culpado foi outro módulo, que usou sua própria dependência do mangusto. Esses módulos têm algo como "mongoose": "^4.1.1" em seu package.json, mas como esses módulos são atualizados anualmente (se houver) - eles não têm a parte de configuração da promessa. @protoEvangelium você está usando algum outro módulo?

@SAudelOG Obrigado pela resposta

@varunjayaraman Eu apenas comecei a testar a adição de usuários ao Mongo usando Mongoose e Mocha. É um projeto barebones até agora.

@Spown estou usando:
"mocha": "^3.2.0", "mongoose": "^4.8.1", "nodemon": "^1.11.0"

Obrigado :)

@protoEvangelium espere um minuto, você tentou isso?

const mongoose = require('mongoose')
mongoose.Promise = global.Promise // <--
const Schema = mongoose.Schema
const UserSchema = new Schema({
  name: String,
})
const User = mongoose.model('user', UserSchema)
module.exports = User

se você criar um modelo a partir de uma instância do mangusto cuja promessa não foi redefinida - cada consulta nesse modelo lançaria o aviso.

@Spown

Eu me deparei com este tópico na hora certa. Eu estava recebendo o mesmo aviso sempre que estava salvando informações. Acontece que eu estava criando um modelo a partir de uma instância do mangusto e não estava redefinindo-o. Exigir o bluebird e defini-lo como mongoose.Promise resolveu a mensagem de erro.

Muito obrigado!

@Spown Obrigado senhor! Essa era a questão. Curiosamente, eu defini mongoose.Promise = global.Promise; no meu arquivo test_helper.js logo antes de conectar ao Mongoose. Mudei o mongoose.Promise = global.Promise; para o meu arquivo onde defini o Schema e funcionou!!!! Chega de aviso de depreciação 👍

const mongoose = require('mongoose')
mongoose.Promise = global.Promise;
const Schema = mongoose.Schema

Estou recebendo esse problema ao usar virtuais "preenchíveis" em meus esquemas. Executando meu aplicativo com --trace-deprecations , você pode ver o culpado:

(node:8846) DeprecationWarning: Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead: http://mongoosejs.com/docs/promises.html
    at model.wrappedPointCut [as init] (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mongoose/lib/services/model/applyHooks.js:141:26)
    at completeMany (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mongoose/lib/query.js:1254:12)
    at Immediate.cb (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mongoose/lib/query.js:1117:13)
    at Immediate.<anonymous> (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mquery/lib/utils.js:137:16)
    at runCallback (timers.js:651:20)
    at tryOnImmediate (timers.js:624:5)
    at processImmediate [as _immediateCallback] (timers.js:596:5)

Eu defini a promessa (observe que estou usando o TypeScript):

import * as mongoose from "mongoose";
(<any>mongoose).Promise = global.Promise;
mongoose.connect('mongodb://localhost/blah')

Alguma ideia? Devo definir a promessa em todos os modelos que usam virtuais "preenchíveis"? Espere, eu vou tentar isso e voltar com como foi.

Ok, depois de alguns ajustes, descobri que ainda preciso definir o Promise no meu esquema, mesmo que o tenha definido no index do meu servidor.

No meu caso, a coleção website_pages foi a primeira coleção a ser consultada pelo meu sistema, definir o mongoose.Promise para global.Promise somente neste esquema corrigiu o problema e eu estava não é necessário configurá-lo em todos os esquemas.

Por que não usar ES6 Promises? Eles não estão disponíveis em todos os lugares agora?

mongoose.Promise = Promise; // eh?

Obrigado @Spown , enfrentei o mesmo aviso de depreciação desde que coloquei mongoose.Promise = global.Promise após importar o modelo. Agora o aviso de descontinuação desapareceu.

Declarar mongoose.Promise = global.Promise no arquivo de modelo, conforme mencionado por @Spown , funciona. Isso ocorre devido ao armazenamento em cache dos módulos necessários do nó . Isso parece inconstante embora. Não existe uma maneira de garantir que o test_helpers.js seja carregado primeiro para que eu possa definir a função de promessa do mangusto neste arquivo?

Não há como garantir isso...

pessoalmente, eu require mangusto apenas uma vez em meus projetos, então eu o coloco em um objeto Singleton global e o uso em todos os lugares para todos os propósitos de banco de dados. Não exatamente gracioso, mas principalmente à prova de balas. e eu tenho feito isso muito antes da depreciação simplesmente porque se você usar uma conexão personalizada, o que eu faço (uma conexão feita via mongoose.createConnection() em vez de mongoose.connect() ) - você precisa criar modelos da instância do mangusto vinculada a esta conexão. Caso contrário, simplesmente não funcionará, o que é muito pior do que um aviso irritante.

sim, eu faço o mesmo que @Spown. Certamente não é o ideal, mas é a única maneira de manter o mangusto compatível com versões anteriores até o próximo grande lançamento, quando podemos descontinuar completamente o mpromise

libs/mongoose.js

import mongoose from 'mongoose'; // real mongoose only be required once here 

mongoose.Promise = global.Promise; // so that you dont have to do this on every require
const Schema = mongoose.Schema;

export {
  mongoose as default, // kind of singleton
  mongoose,
  Schema,
};

index.js

import mongoose from './libs/mongoose';
mongoose.connect(process.env.MONGODB_URI);

models/user.js

import {mongoose, Schema} from '../libs/mongoose';

export default mongoose.model('User', new Schema({
  name: String,
  password: String,
}));

As chamadas @howward require() são armazenadas em cache.

Então, se entendi corretamente, preciso definir a promessa antes de cada declaração de esquema em vez de fazê-lo apenas em um local (por exemplo, no meu arquivo de índice ou onde estou configurando a conexão)
Esta não é uma boa prática, vale a pena considerar mudá-la para uma função, algo como:
mongoose.setPromise(global.Promise);

@sh-guti acho que sim, tive o mesmo problema e esse pedaço de código resolve isso.

Neste ponto eu não sei, se usar callbacks ou promessas. LOL.

Usar

mongoose.createConnection(URI)

Alguém pode explicar, por que o mangusto da Terra nega a existência de Promises nativas e não pode usá-las fora da caixa?

Compatibilidade com versões anteriores. O Mongoose 4.x já existia há mais de um ano antes do lançamento do nó 4. Vamos mudar com o próximo lançamento de quebra para trás.

Quando será isso?

mongoose.createConnection(URI) causa um bug muito estranho com Mongoose , horas de depuração com consultas não funcionando . acabou voltando para

mongoose.connect(process.env.MONGODB); de mongoose.createConnection(process.env.MONGODB)

como uma nota lateral, ele parou o aviso de depreciação .. mas parou tudo funcionando ...

@MickL teremos um rc0 nas próximas semanas, siga o mangusto no twitter ou entre no canal do slack para atualizações