Mongoose: DeprecationWarning: Mongoose: mpromise (die Standardversprechenbibliothek von mongoose) ist mit 4.8.0 und 4.8.1 veraltet

Können Sie den Code einfügen, der den Fehler tatsächlich verursacht? Dieser Code wird nicht verwendet, weil Sie noch kein Versprechen verwendet haben (es sei denn, Sie sagen, dass das von Ihnen veröffentlichte Verbindungs-Snippet die Warnung erzeugt?)

Nein, das Verbindungs-Snippet erzeugt keine Warnung. Das folgende Newuser-Save-Snippet ist der Code, der die Warnung erzeugt, jedoch nur beim ersten Ausführen des Codes nach dem Start der Anwendung (die Warnung tritt in Mungo-Versionen 4.7.9 und früheren Versionen erneut nicht auf):

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

Das Benutzerschema lautet wie folgt:

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

Ich kann das gleiche Problem mit Mungo v4.8.1 & node.js v7.5.0 bestätigen.

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 danke für das

Das Schema wird aus der Schemadatei exportiert und dort wie folgt deklariert:

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

und das Schema wird in die Datei importiert, in der newuser.save wie folgt aufgerufen wird:

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

Das in meinem ersten Beitrag gezeigte Verbindungs-Snippet (bei dem die Verbindung geöffnet ist und der Mungo-Promise-Konstruktor festgelegt ist) befindet sich in der Datei app.js, die bei der Initialisierung beim Start der Anwendung ausgeführt wird.

Das in meinem zweiten Beitrag gezeigte Snippet newuser.save wird aus der Datei ausgeführt, in die das Benutzerschema importiert wird, und newuser.save wird ausgeführt, wenn ein Benutzer mit der Anwendung interagiert und eine bestimmte Route ausgeführt wird, die weit nach der Initialisierung der Anwendung liegt Wurde vervollständigt.

Die Warnung tritt nur beim ersten Ausführen des Codes newuser.save nach dem Start der Anwendung auf, obwohl derselbe Code newuser.save nach dem Start mehrmals ausgeführt wird, und die Warnung scheint bei Mungo-Versionen 4.7.9 und früheren Versionen nicht mehr aufzutreten.

@ stevenelson74708 Ich muss alle Komponenten sehen, die beim Start Ihrer App eine Rolle spielen. Viele Leute haben in letzter Zeit Probleme in diesem Zusammenhang eröffnet, und jeder einzelne ist darauf zurückzuführen, dass der Versprechen-Konstruktor nicht richtig festgelegt wurde. Ich vermute also, dass Sie in der Reihenfolge, in der Sie mongoose.Promise haben, etwas falsch gemacht haben.

Kann ich Ihren Code auf irgendeine Weise sehen?

Unten finden Sie den gesamten Code (in exakter Reihenfolge) in der Initialisierung von app.js, der sich auf die Mungo-Konfiguration bezieht, einschließlich der Einstellung von mongoose.Promise. Die Warnung tritt nicht auf, wenn der Initialisierungscode ausgeführt wird. Die Warnung tritt nur beim ersten Ausführen des Codes newuser.save (siehe in meinem vorherigen Beitrag) auf, nachdem die Anwendung initialisiert wurde. Es gibt findOneAndUpdate-Aufrufe, die vor dem Speichern ausgeführt werden und die Warnung nicht verursachen. Es scheint also, dass nur die Speicherfunktion die Warnung verursacht.

Die Mungo-Konfiguration ist eines der ersten Dinge, die bei der Initialisierung auftreten. Sollte die Mungo-Konfiguration später bei der Initialisierung auftreten, z. B. nach der createServer-Funktionalität?

Auch hier scheint die Warnung in Mungo-Versionen 4.7.9 und früheren Versionen nicht mehr aufzutreten:

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

Nein, die Konfiguration kann an erster Stelle stehen. Ist diese Datei der Einstiegspunkt für Ihre App oder gibt es eine Datei davor?

Die Datei app.js ist der Einstiegspunkt für die Anwendung. Die Anwendung kann durch Eingabe des Knotens app.js in der Befehlszeile aufgerufen werden.

Ich habe das gleiche Problem mit Mungo 4.8.1 und Knoten 7.5.0. Ich benutze auch Typescript und versuche, Bluebird für Versprechen einzustecken. Ich habe herausgefunden, dass die Warnung verschwindet, wenn ich diesen Code hinzufüge:

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

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

in JEDER Datei, die etwas von 'Mungo' importiert. Also muss ich das in jeder Modelldatei (Datei, in der ich mein Schema definiere) tun, stattdessen nur in der Einstiegspunktdatei.

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

Druckt diese Warnung nicht aus, es gibt also noch etwas anderes.

@vladimirdjurdjevic Dies bedeutet, dass Sie irgendwo eine Bibliothek festlegen . Ich benutze TS nicht, also weiß ich nicht, ob das etwas damit zu tun hat.

Ich habe die Versprechen-Bibliothek wie oben in der Datei app.js gezeigt, die der Einstiegspunkt der Anwendung ist, und dann, wenn die erste newuser.save ausgeführt wird (lange nachdem die Versprechen-Bibliothek gesetzt wurde), wie oben gezeigt, tritt die Warnung auf. Die Datei newuser.save ist die erste mongoose asynchrone Operation, die auftritt, jedoch lange nachdem das Versprechen lib für die Verbindung festgelegt wurde.

Muss die Versprechen-Bibliothek in jeder Datei festgelegt werden, die auf mongoose asynchrone Funktionen zugreift, anstatt die Versprechen-Bibliothek nur einmal festzulegen, wenn die Mungo-Verbindung konfiguriert ist?

@ stevenelson74708 Ich hatte das gleiche Problem. Ich dachte, ich hätte es gelöst mit: mongoose.Promise = global.Promise im Einstiegspunkt der Anwendung. Sieht so aus, als ob Sie es in jeder Datei benötigen, die auf Mungo-Versprechen zugreift. Sehr ärgerlich. Legen Sie einfach die Mungo-Konfiguration in einer separaten Datei fest, exportieren Sie sie und importieren Sie sie, wo immer dies erforderlich ist.

Ich habe auch kürzlich bemerkt, dass ich diese Warnung erhalte, obwohl ich das Versprechen in meiner Datei app.js festgelegt habe. Ich habe versucht, sowohl native als auch Bluebird mit den gleichen Ergebnissen zu verwenden.

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

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

Ich importiere Mungo in einige meiner Modelle und verwende sie in Schemamethoden. Ich habe das Problem gelöst, indem ich die Versprechensbibliothek in eine Datei gesetzt habe, die Mungo selbst importiert (siehe TODO im Snippet unten). Ich kann mich nicht erinnern, die Warnung vor einigen Monaten bei einer ähnlichen Codestruktur gesehen zu haben.

// 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 Du bist besser dran,

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

Auf diese Weise müssen Sie nicht mehrmals "mongoose.Promise = bluebird" schreiben :)

In meiner Situation wurde die Verfallswarnung angezeigt, wenn auf Unterdokumente mit der Syntax .then() reagiert wurde, jedoch nicht auf übergeordnete Dokumente. Die gelegentliche Warnung ließ mich glauben, ich hätte Syntaxprobleme beim Umgang mit untergeordneten Dokumenten, aber es war tatsächlich das Fehlen einer Versprechenszeile in der Modelldatei, wie andere oben empfohlen haben.

Ja, es scheint, dass das Festlegen von mongoose.Promise in den Schemadateien, in die mongoose.model exportiert wird, die Warnung in Mungo-Versionen 4.8 und höher beseitigt.

Ja, wenn Sie den Mungo-Singleton als Ihren eigenen mutierten Export herumreichen, würde dies das Problem umgehen, aber es ist zugegebenermaßen ein kleiner Hack.

Zu diesem Zeitpunkt ist mir nicht klar, was genau das "richtige" Mungo-Setup / die richtige Konfiguration ist, um die Warnung zu vermeiden. Handelt es sich bei dieser Warnung um ein Problem mit aktuellen Mungo-Versionen oder um einen Hinweis auf eine fehlerhafte Mungo-Einrichtung? Gibt es ein empfohlenes Mungo-Setup, das die Warnung verhindert? Wiederum tritt diese Warnung erst ab der Mungo-Version 4.8.0 auf.

Ich habe das gleiche Problem beim Einstellen des globalen Mungos.

Ich habe nachverfolgt, es kann die Drossel richtig auf versprechen_provider setzen, aber als ich versuchte, das Versprechen zurückzubekommen, wird es das ES6 zurückgeben.

Ich ging einfach durch und fügte hinzu

mongoose.Promise = global.Promise

Unmittelbar nach dem Erfordernis / Importieren von Mungo in jeder Quelldatei, die es verwendet, und obwohl dies übertrieben ist, dauerte es sehr wenig Nachdenken und nicht sehr viel Zeit, und es hat es vollständig behoben. Also nicht wirklich das größte Angebot.

Es stellt mein zugegebenermaßen begrenztes Wissen darüber in Frage, wie Arbeit benötigt und importiert werden muss. Ich hatte den Eindruck, dass Sie, egal wie oft Sie etwas benötigen, immer die gleiche Instanz erhalten. Wenn Sie also das Versprechen einmal festlegen, sollten Sie denken. Es ist also ein bisschen kontraintuitiv.

Hallo
Ich habe einen Beispielcode, der das Problem verursacht

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 ist nur ein einfaches Modell mit einem Feld für den Namen)

Aus irgendeinem Grund tritt das Problem zuerst auf, wenn Sie res.save(); . Ohne das funktioniert alles wie gewohnt.

Ich glaube, dass dieses Problem darauf zurückzuführen ist, dass Babel die Reihenfolge beim Transpilieren des Codes geändert hat. Wenn babel transpiliert, werden alle Importe nach oben verschoben. Wenn also das test.model in meinem Beispiel importiert wird, ist die Promise-Bibliothek immer noch mpromise zugewiesen.

Ich verwende Node.js 6.10.0 und Mongoose 4.8.5 und habe dieses Problem behoben.

Ich speichere mein Benutzerobjekt:

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

Und ich habe den gleichen Fehler. Ich habe es so versucht:

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

Und so:

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

Aber ich habe wieder die veraltete Warnung. Wie kann ich das beheben?

So beheben Sie die Verwarnung Warnung:

var mongoose = require('mongoose');

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

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

Ja, es funktioniert, wenn ich das in mein Modell stecke. Also müssen wir Mungo initiieren. Versprechen Sie in jedem Modell.

Ich denke, @ stevenelson74708 hat einen ausgezeichneten Punkt, wenn man At this point it's unclear to me as to exactly what the "proper" mongoose setup/configuration to avoid the warning is. sagt

Ja, eine Lösung wäre, alle Mungo-Modelldateien noch einmal durchzugehen und nach dem Import mongoose.Promise = global.Promise hinzuzufügen. Da dieses Problem jedoch erst kürzlich aufgetreten ist, wäre es schön, eine konkretere Antwort auf die Absichten zu erhalten oder Ursachen dahinter. Ich bin mir derzeit nicht sicher, ob es sich um ein Problem handelt, das durch Mungo, Babel oder eine Kombination aus beiden verursacht wird.

Wahrscheinlich ein Betrüger von # 5030. Versuchen Sie ein Upgrade auf> = 4.9.1.

Für die Aufzeichnung, @bricss Lösung hat ziemlich gut für mich funktioniert :)

Die Lösung kommt zunächst von @ steve-p-com. Nicht von @bricss.
@ vkarpov15 gleiche Warnung mit 4.9.3.
@stillesjo es ist nichts mit babel. Die Warnung tritt auch auf nativ ohne Babel auf Knoten 7.8.0 auf.

Ich habe seit Version 4.9.3 keine Warnungen mehr

Selbst wenn wir für jedes Modell mongoose.Promise = global.Promise; denke ich, dass es keine ideale Lösung ist, oder? Warum nicht global.Promise als Standard verwenden und Benutzer ändern lassen, wenn sie möchten?

Unit-Test meiner Modelle. Ich muss es einschließen, damit die Warnung nicht angezeigt wird, wenn Tests lokal oder auf CI ausgeführt werden.
Ich verwende "mongoose": "4.10.4" mit dem Knoten v7.10.0

@lesterzone

Um eine DRY-Lösung hinzuzufügen, richten Sie sie dort ein, wo Sie die Verbindung mit der Datenbank initialisieren, anstatt sie in jedem Modell festzulegen.

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

scheint zu funktionieren

Das wird aber nicht unbedingt für alle funktionieren. Dies hängt von Ihrer Codestruktur ab. Wenn für die Datei mit dem Verbindungscode beispielsweise Modelle aus separaten Quelldateien erforderlich sind, bedeutet dies, dass diese Quelldateien geladen werden, bevor das globale Versprechen in der Datei festgelegt wurde, die den Verbindungscode enthält. Diese Modelle verwenden weiterhin den Standardwert für das Versprechen. Der sichere Weg besteht einfach darin, das globale Versprechen in jeder Quelldatei festzulegen, für die Mungo erforderlich ist.

das funktioniert bei mir
`` ``
Mungo aus 'Mungo' importieren;
Konfiguration aus './config' importieren;
Bluebird aus 'Bluebird' importieren;

Standard-Rückruf exportieren => {
Mungo.Promise = Bluebird;
// Verbindung zur Datenbank von der Instanz der Datenbank in der Konfigurationsdatei herstellen
let db = mongoose.connect (config.mongoUrl, {useMongoClient: true});
Rückruf (db);
}}
`` ``

So mache ich es.

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

Sie müssen die .create-Funktion verwenden, die mit Mungo geliefert wird, anstatt .save,
Ich habe meine geändert und es behebt das Problem

Ich bin am 4.13.9 und das existiert noch. @ Gilbert136 Lösung behebt dieses