Mongoose: DeprecationWarning: `open()` ist in Mongoose >= 4.11.0 veraltet, verwenden Sie stattdessen `openUri()`

+1, ich habe keine Ahnung, wo ich diese Warnung beheben soll

Die Warnung bezieht sich tatsächlich auf einen Code in Mongoose, wenn die Verbindungszeichenfolge einen Replikatsatz hat:

Mongoose.prototype.connect = function() {
  var conn = this.connection;
  if ((arguments.length === 2 || arguments.length === 3) &&
      typeof arguments[0] === 'string' &&
      typeof arguments[1] === 'object' &&
      arguments[1].useMongoClient === true) {
    return conn.openUri(arguments[0], arguments[1], arguments[2]);
  }
  if (rgxReplSet.test(arguments[0]) || checkReplicaSetInUri(arguments[0])) {
    return new MongooseThenable(this, conn.openSet.apply(conn, arguments));
  }

  return new MongooseThenable(this, conn.open.apply(conn, arguments));
};

@tinovyatkin

Das ist also ein Bug?

sieht nach einem Fehler aus, können wir dies umgehen, indem wir useMongoClient: true zu den Optionen hinzufügen (Sie sehen dann möglicherweise eine veraltete Version des MongoDB-Treibers, aber das löst keinen Fehler aus)

Wenn Sie useMongoClient: true hinzufügen, verschwindet die Nachricht, aber dann werden meine Dokumente einfach nicht mehr geladen. Ich habe es nicht tiefer debuggt, aber ich würde es vorziehen, zuerst Best Practices zu hören, bevor ich meinen Code anpasse.

Meine Anwendung funktioniert auch nicht mit der oben vorgeschlagenen Problemumgehung. Es führt einfach keine MyModel.find-Methode mehr aus und gibt keinen Fehler und kein Timeout aus.

Der Grund, warum die Option „useMongoclient: true“ in den meisten Fällen nicht funktioniert, ist, dass für diese Option jedes verbindungsbezogene Mungo-Objekt ein Dummy-Objekt zurückgibt, weil es nicht in der Lage ist, auf Mongodb zuzugreifen

Ich habe versucht, es wie zu verwenden

const server = express();
mongoose.connect('mongodb://localhost/advisorDemoTestDB', { useMongoClient: true })
    .then(() => require('./db-init')(server))
    .catch(err => console.error(err));

aber es funktioniert nicht

Habe das gleiche Problem, auch ohne Replikat-Sets.

Habe das gleiche Problem:

(node:4138) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0,
 use `openUri()` instead, or set the `useMongoClient` option if using `connect()` 
or `createConnection()`

Dasselbe...

Nachdem ich meiner Mongo-Verbindung den folgenden Code hinzugefügt habe, kann ich jetzt nichts mehr abfragen.
{useMongoClient: true}.
Irgendwelche Vorschläge werden geschätzt!!

+1 gleich mit Replikat-Sets, kein Sharding

+1

+1

+1

+1

+1

+1

+1

Die einfachste Lösung dafür; " npm remove mongoose " dann " npm install [email protected] --save " Problem gelöst. Ein Upgrade ist nicht immer die beste Option.

+1

+1

Ich bekomme 2 Meldungen:

(node:9260) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0,
use `openUri()` instead, or set the `useMongoClient` option if using `connect()`
or `createConnection()`

Server started on port 3000

Db.prototype.authenticate method will no longer be available in the next major
release 3.x as MongoDB 3.6 will only allow auth against users in the admin db
and will no longer allow multiple credentials on a socket. Please authenticate
using MongoClient.connect with auth credentials.

Der erste Fehler trat in 4.11.0 auf. Der zweite Fehler trat auch in der vorherigen Version von Mongoose auf.

plhosk, der zweite hätte in 4.11 behoben werden sollen, aber sieht so aus, als wäre er immer noch da, auch für mich.

+1

+1 leider.

4.10.8 ohne Probleme installiert. Bitte erwägen Sie, npm install mongoose --save auf den Standardwert 4.10.8 zu ändern, bis 11 stabil ist.

+1

+1

+1

+1

Ich habe dieses Problem auch gefunden.
__Knotenversion__: v6.10.0

__MongoDB__-Umgebung: (Ich habe die neueste Version des Mongo-Docker-Containers ausgeführt)

2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] db version v3.4.5
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] git version: 520b8f3092c48d934f0cd78ab5f40fe594f96863
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] OpenSSL version: OpenSSL 1.0.1t  3 May 2016
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] allocator: tcmalloc
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] modules: none
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] build environment:
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     distmod: debian81
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     distarch: x86_64
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     target_arch: x86_64
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] options: { security: { authorization: "enabled" } }

Meine Verbindungskonfiguration:

var dbURL = `mongodb://${dbHost}:${dbPort}/${dbName}?authSource=admin`;
var dbAuth = { 
    useMongoClient: false
    user: dbUser,
    pass: dbPass
}
mongoose.connect(dbURL, dbAuth);

Wenn ich useMongoClient verwende, um falsch zu sein. Mungo zeigt folgende Warnungen:

(node:7868) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, or set the `useMongoClient` option if using `connect()` or `createConnection()`
Express server listening on port 3222 in development mode
Db.prototype.authenticate method will no longer be available in the next major release 3.x as MongoDB 3.6 will only allow auth against users in the admin db and will no longer allow multiple credentials on a socket. Please authenticate u
sing MongoClient.connect with auth credentials.

Aber es funktioniert gut.

Als ich es jedoch auf true setzte, fand ich diesen Fehler:

Unhandled rejection MongoError: not authorized on users to execute command { listIndexes: "sessions", cursor: {} }
    at Function.MongoError.create (<my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\error.js:31:11)
    at queryCallback (<my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\cursor.js:212:36)
    at <my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\connection\pool.js:469:18
    at _combinedTickCallback (internal/process/next_tick.js:67:7)
    at process._tickCallback (internal/process/next_tick.js:98:9)

Ich versuche auch, authSource=admin auch aus der Verbindungs-URL zu entfernen, aber es funktioniert immer noch nicht

(node:451) DeprecationWarnung: open() ist in Mongoose >= 4.11.0 veraltet, verwenden
openUri() stattdessen, oder setzen Sie die Option useMongoClient , wenn Sie connect() oder createConnection() verwenden
Die Db.prototype.authenticate-Methode wird in der nächsten großen Re nicht mehr verfügbar sein
lease 3.x, da MongoDB 3.6 nur die Authentifizierung gegen Benutzer in der Admin-Datenbank und w zulässt
Kranke erlauben nicht mehr mehrere Anmeldeinformationen auf einem Socket. Bitte authentifizieren Sie sich mit M
ongoClient.connect mit Authentifizierungsdaten.

Ich bekomme dieses Problem mit Mongoose Version 4.11.0 und MongoDB Version 3.4.5

+1

+1

Verwenden

mongoose.createConnection(URI)

@nandofalcao Bei Verwendung von:

• mongoose.createConnection (URI);
• mongoose.connect (URI, {useMongoClient: true});

Anscheinend kann ich keine neuen Datensätze speichern.

let userSchema = mongoose.Schema({ name: String });
let User = mongoose.model('User', userSchema);
let joao = new User({ name: 'NewJoao ' });
joao.save((err) => err ? throw err : console.log('User created!'));//nothing happens

Heute Abend mehrsprachig hinzufügen und +1 erleben.

// Load Mongoose
const mongoose = require('mongoose');
// import mongoose from 'mongoose' didn't give access to .connect()

// Use native Promises
mongoose.Promise = global.Promise;

// Connect database
export const Mongoose = new Promise((resolve, reject) => {
  const uri = `mongodb://${Singleton.currentConfig.databases.mongodb.host}/${Singleton.currentConfig.databases.mongodb.database}`;

  const options = {
    user: Singleton.currentConfig.databases.mongodb.user,
    pass: Singleton.currentConfig.databases.mongodb.password,
    server: {
      reconnectTries: Singleton.currentConfig.databases.mongodb.reconnectTries,
      reconnectInterval: Singleton.currentConfig.databases.mongodb.reconnectInterval,
      socketOptions: {
        keepAlive: Singleton.currentConfig.databases.mongodb.keepAlive,
        connectTimeoutMS: Singleton.currentConfig.databases.mongodb.connectTimeoutMS
      },
    },
  };

  // Initiate document store
  mongoose.connect(uri, options)

  // Check for anomalies
  .then((connected) => {
    if (mongoose.connection.readyState !== 1) {
      reject(connected);
    }
    resolve(connected);
  })

  // Complete meltdown
  .catch((error) => {
    console.log(`MongoDB Connection Error: ${error}`);
    process.exit(0);
  });
});

+1

und ich bekomme die 2. Nachricht:

[2017-06-27 16:14:23.702] [INFO] :: - Server gestartet in Port 2000

(node:1193) DeprecationWarning: open() ist in Mongoose >= 4.11.0 veraltet, verwenden Sie stattdessen openUri() oder setzen Sie die Option useMongoClient , wenn Sie connect() verwenden oder createConnection()

Die Methode „Db.prototype.authenticate“ wird in der nächsten Hauptversion 3.x nicht mehr verfügbar sein, da MongoDB 3.6 nur die Authentifizierung für Benutzer in der Admin-Datenbank zulässt und nicht mehr mehrere Anmeldeinformationen für einen Socket zulässt. Bitte authentifizieren Sie sich mit MongoClient.connect mit Authentifizierungsdaten.

+1

+1

+1

+1

+1

Kann das jemand sperren, um nutzlose +1 zu verhindern?

Aus Höflichkeit gegenüber Abonnenten dieses Threads antworten Sie bitte nicht mehr mit +1, da dies nutzlose E-Mail-Benachrichtigungen generiert. Dies ist kein Forum. Wenn Sie diesem Thread folgen möchten, verwenden Sie die Schaltfläche zum Abonnieren in der rechten Seitenleiste. Sie könnten auch selbst recherchieren und Lösungen beisteuern.

Ich habe die Version zurück auf 4.10.8 geändert und es funktioniert jetzt einwandfrei.

Sieht so aus, als hätte ValYouW hier eine mögliche Lösung für das Problem beim Laden von Dokumenten: #5404

mongoose.connection.openUri('mongodb://127.0.0.1/camp_v12')

hat das jemand probiert? Meine veraltete Warnung verschwand, als ich dies verwendete, sie stammte aus der Dokumentation

http://mongoosejs.com/docs/connections.html

@crisamdegracia , das davon ausgeht, dass Sie bereits eine Verbindung haben

// Or, if you already have a connection
connection.openUri('mongodb://localhost/myapp', { /* options */ });

was wir nicht tun (zumindest ich, da ich mich mit der mongoose.connect-Methode mit mongodb verbunden habe)

mongoose.connect(config.get('mongo'), {
  useMongoClient: true,
});

Ich konnte kein Dokument finden... Was stimmt nicht?

+1

Nachdem Sie sich also das verknüpfte Problem von @phased90 angesehen haben , das erklärt, dass Sie sich folgendermaßen verbinden können:

const mongoose = require('mongoose');

mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost/test', {useMongoClient: true})
    .then(() => {
        let Cat = mongoose.model('Cat', {name: String});
        let kitty = new Cat({name: 'Zildjian'});

        kitty.save(err => {
            if (err) {
                console.log(err);
            } else {
                console.log('meow');
            }
        });
    })
    .catch(err => console.error(err));

Ich habe den Code schnell durchgesehen und es scheint, dass 4.11 MongooseThenable zurückgibt, außer wenn die Option {useMongoClient: true} bereitgestellt wird. In diesem Fall wird Connection.prototype.openUri aufgerufen, was eine neue Instanz von Promise.ES6 zurückgibt. Sollte dieser Connection.prototype.openUri Call in MongooseThenable verpackt werden?

Ich entschuldige mich für die Frage, dies ist das erste Mal, dass ich mir diese Codebasis anschaue, daher bin ich mir etwas unsicher. Aber ich würde gerne versuchen, eine Lösung zu finden, wenn ich klären kann, ob Moongoose.prototype.connect immer eine Instanz von MongooseThenable zurückgeben sollte.

Beachten Sie, dass die Verwendung {useMongoClient: true} dazu führt, dass Connection.prototype.openUri aufgerufen wird, was keine gepufferten Befehle auslöst, die aufgrund von #5404 __bevor____ eine Verbindung zu einer Datenbank hergestellt wurden

+1

Tut mir leid, die Dinge waren verrückt, wir werden uns das gleich ansehen.

@varunjayaraman , kein Grund, sich zu entschuldigen, Kumpel. Die Leute können entweder warten oder versuchen, es selbst zu beheben.

+1

In Bezug auf das eigentliche Problem, das geöffnet wurde, ist die Verfallswarnung kein Fehler, sondern nur eine Warnung: Mongoose wird seine aktuelle Verbindungslogik verwerfen, also sollten Sie den Parameter useMongoClient übergeben. Diese finden Sie in der Dokumentation

In einer separaten Anmerkung sieht es so aus, als wäre dies eine rückwärts brechende Änderung, hoffentlich kann dies in der nächsten Nebenversion behoben werden (oder vielleicht auch nicht, ich habe hier sehr wenig Schlaf):

dies würde normalerweise funktionieren (abgesehen vom Teil useMongoClient , der neu ist):

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5399`


exec()
  .then(() => {
    console.log('successfully ran program');
    process.exit(0);
  })
  .catch(error => {
    console.error(`Error: ${ error }\n${ error.stack }`);
  });


function exec() {
  return co(function*() {
    const db = mongoose.createConnection(`mongodb://localhost:27017/${ GITHUB_ISSUE }`, { useMongoClient: true })
    const schema = new mongoose.Schema({
      name: String
    });


    const Model = db.model('Model', schema);
  });
}

Dies scheint einen Fehler für mich auszulösen, da db.model keine Funktion mehr ist.

Bei Verwendung mongoose.model funktioniert es:

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5399`


exec()
  .then(() => {
    console.log('successfully ran program');
    process.exit(0);
  })
  .catch(error => {
    console.error(`Error: ${error}\n${error.stack}`);
  });


function exec() {
  return co(function* () {
    const db = mongoose.connect(`mongodb://localhost:27017/${GITHUB_ISSUE}`, { useMongoClient: true })

    return db
      .then(() => {
        const schema = new mongoose.Schema({
          name: String
        });


        const Model = mongoose.model('Model', schema);

        return Model.create({ name: 'test' });
      })
      .then(doc => console.log(doc));

  });
}

@varunjayaraman Ich habe gerade Mongoose aktualisiert und useMongoClient: true verwendet, wie Sie vorschlagen, aber ich habe ein Problem.
Laut der offiziellen Mongoose-Dokumentation werden die Optionen user und pass nicht unterstützt:

the options [user] is not supported
the options [pass] is not supported

Und ja, die Authentifizierung ist fehlgeschlagen. :-1:

Ich werde versuchen, Benutzer hinzuzufügen und stattdessen die Verbindungszeichenfolge zu übergeben.
Es funktioniert, wenn ich Benutzername und Passwort in die Verbindungszeichenfolge einfüge. Vielleicht sollten Sie die Dokumentation aktualisieren. 😐

@itpcc versuchen, 4.10.8 -Version zu verwenden, ist derzeit die beste Lösung.

npm remove mongoose
npm install [email protected] --save

Bildnachweis: @Chenz62

@CQBinh Danke für deinen Rat. Die Kommentare dazu habe ich bereits gelesen.
Ich glaube jedoch nicht, dass die Verwendung der älteren Version im Moment die beste Lösung ist. Und es kann durch Einfügen in die Verbindungszeichenfolge aufgelöst werden.
Ich bin nur verwirrt, weil es im Dokument erwähnt wurde, aber es funktioniert nicht. :/
BTW, ich melde das hier als neues Problem

@varunjayaraman Wenn db.model nicht mehr vorhanden ist, wie würde man mit mehreren verschiedenen Mungo-Verbindungen mit verschiedenen Modellen umgehen?

B. model1 und model2 an mongooseConnection1 angeschlossen und model3 und model4 an mongooseConnection2 angeschlossen.

Früher wurde dies durch Aufrufen von mongoose.createConnection für jede der Verbindungen und Anhängen der Modelle an jeden dieser Rückgabewerte durchgeführt.

Edit: Oder funktioniert es in diesem Fall noch:

const conn = mongoose.createConnection(...);
const Model = conn.model('ModelName', schema);

+1

@boyce-ywr ERNSTHAFT, noch ein +1??? Was ist los mit euch Leuten??
Poste konstruktive Kommentare, nicht solche Sachen.

In Bezug auf Mungo ist mir nicht klar, ob die Methode mongoose.connect() in zukünftigen Versionen ersetzt wird oder nicht. Könnte jemand bitte erklären?

@simonemazzoni Du hast Recht, sie SPAMen uns.

Wenn Sie in die Benachrichtigungen für diesen Thread aufgenommen werden möchten, müssen Sie ihn nur abonnieren (es gibt eine Schaltfläche am Anfang des Threads).

Alles, was Sie tun, wenn Sie +1 geben , ist, allen hier eine E- Mail mit dem Spruch zu senden

Hallo ich bin hier!

Uns ist es egal , wir warten auf konstruktive Kommentare und eine Lösung .

Und warum löschen nicht alle von euch +1 eure Beiträge aus dieser Liste, sie sind ein Dorn im Auge und ein Ärgernis, vorbeiscrollen zu müssen, nur um zu den echten Kommentaren zu gelangen.

Wie einige Leute schon sagten, ist die einzige "Lösung", zu [email protected]_ zurückzukehren ...
Zumindest für jetzt!

Sieht aus wie ein Fehler, ging zurück zu [email protected] , um das Problem zu lösen

Verwenden Sie mongoose.createConnection(...) anstelle von mongoose.connect(...)

Hier ist ein vollständiges Arbeitsbeispiel für die Verwendung von [email protected] basierend auf der Empfehlung von @diegoazh

const mongoose = require('mongoose')
mongoose.Promise = require('bluebird')  // optional, use this to get rid of 
                                        // the mpromise DeprecationWarning
const conn = mongoose.createConnection('mongodb://localhost/testDB')
const Schema = mongoose.Schema

const UserSchema = new Schema({
    username: String,
    email: String
})

const User = conn.model('User', UserSchema)
module.exports = User

@midnightcodr Also lassen wir die Verbindung einfach fallen und verwenden stattdessen createConnection?

@bertolo1988 Genau wie ppl zu diesem Problem vorgeschlagen hat, gibt es derzeit zwei Problemumgehungen

1. Zurückfallen auf 4.10.8
2. Verwenden Sie das neue Muster, wenn Sie bei der neuen Version bleiben möchten

const conn = mongoose.createConnection(...)
const Model = conn.model(...)

Ich persönlich bevorzuge die zweite Lösung.

Danke!!!
gelöst durch createConnection, und verwenden Sie diese Verbindung, um ein Modell zu erstellen (anstelle von Mungo)

let mongoose = require('mongoose');

mongoose.Promise = global.Promise;

module.exports = mongoose;

const mongoose = require('./set-mongoose');
module.exports = mongoose.createConnection('mongodb://localhost/advisorDemoTestDB');

Das neue Verbindungsmuster erfordert einige Codeänderungen, und je nach Größe Ihres Projekts kann dies viel Zeit und möglicherweise sogar Architekturänderungen bedeuten (angesichts der Tatsache, dass das Erstellen eines Modells eine Verbindung erfordert).

Es wäre toll gewesen, wenn das alte Verbindungsmodell das neue Verbindungsmodell umhüllen könnte.

Es gibt eine Menge Post, also darf ich versuchen, zusammenzufassen:

1. Die Warnung ist eine veraltete Warnung, was bedeutet, dass es keine Eile gibt. Wenn wir nichts ändern, wird es immer noch so funktionieren, wie es immer war, alles scheint in Ordnung zu sein

2. Gemäß der Warnung wird connect() geändert/geändert und die Übergabe von useMongoClient ist ein Muss. Aber hier ist der mögliche Fehler/das Problem

• connect('myurl', {useMongoClient: true}) => das Dokument wird nicht mehr geladen und es ist nicht möglich, in die Datenbank zu schreiben

• connect('myurl', {useMongoClient: false}) => scheint gut zu funktionieren, aber die Warnung wird immer noch angezeigt

Daher ist der Zweck dieses Problems, die Verwendung von useMongoClient im Falle des Aufrufs der Methode connect zu korrigieren.

Zustimmen?

Obwohl eine Abwertungswarnung tatsächlich "nur" eine Warnung ist, frage ich mich, wenn diese Anzeige angezeigt wird, wann sie tatsächlich entfernt wird. Wenn Mongoose semver folgt, sollte es immer noch im 4.x-Zweig vorhanden sein. Daher sollte es bis zur Veröffentlichung von 5.x immer noch mit Abwärtskompatibilität funktionieren.

Was die Änderung selbst betrifft, ist es etwas ärgerlich, dass ich auf die Schnelle nichts zu dieser Änderung finden konnte, außer der im Changelog erwähnten. Und selbst wenn Sie es ändern, geht immer noch etwas kaputt, und laut mehreren Leuten hier liegt es an dem .model() -Anruf.

Außerdem zeigen sogar die Dokumente immer noch mongoose.connect() und mongoose.model() , was diese Angelegenheit noch verwirrender macht. Die mongoose.connect() -Änderung wird nur unter Verbindungspools erwähnt und nicht auf anderen Teilen dieser Seite . Bleibt also die Frage, ist diese Änderung ein Bug oder gewollt?

Ich weiß nicht, wohin das führt, aber ich habe den größten Teil dieses Wochenendes damit verbracht, eine Verbindung zu MongoDBs Atlas herzustellen. Der native Mongodb-Treiber war sofort betriebsbereit und führte das CRUD-Zeug aus.

Der Versuch, Mungo zum Laufen zu bringen, ist jedoch ein absoluter Albtraum. Wenn ich createConnection mit 4.11 verwende, werden die Clusterverbindungen beendet:

MongoError: connection 4 to cluster0-myshard.mongodb.net:27017 closed

Alternativ könnte ich einstellen

useMongoClient: true

aber dann bekomme ich undefined auf dem connection.model

<info> atlas-api-test.js:65 (Test.testVendors) conn.model undefined

@Archomeda plant nicht, das Legacy-Verbindungsverhalten in 4.x zu entfernen, und 5.x ist blockiert, um die neue Verbindungslogik in einen stabilen Zustand zu versetzen. Es gibt Dokumente zu den Verbindungsdokumenten , die 4.11.1 verbessern wird, und Links dazu sollten hilfreich sein. Bezüglich des model() -Aufrufs, wenn Sie useMongoClient: true angeben, gibt createConnection() keine Verbindung zurück, sondern ein Versprechen, das zu einer Verbindung aufgelöst wird, die Sie zu .then() benötigen https://github.com/Automattic/mongoose/issues/5404#issuecomment -312522539 Bitte zögern Sie nicht, diesbezügliche Bedenken zu Issue #5404 zu äußern.

@mkastner sieht so aus, als würden Sie createConnection() verwenden. Mit useMongoClient: true gibt createConnection() ein Promise zurück, das in eine Verbindung aufgelöst wird. Bitte verwenden Sie await mongoose.createConnection() oder mongoose.createConnection().then()

@peterpeterparker #5404 wies auf ein Problem mit der neuen Verbindungslogik hin, das in 4.11.1 behoben wird und innerhalb der nächsten 24 Stunden veröffentlicht wird.

@cosminn777 welche architektonischen Probleme hast du? Bitte öffnen Sie ein separates Thema, um sie zu diskutieren. Der langfristige Plan ist, dass wir in 5.x Node < 4 nicht unterstützen werden, sodass jeder, der Mongoose verwendet, nativen Zugriff auf Generatoren und/oder Async/Await hat, sodass diese Änderung so einfach wäre wie das Hinzufügen von yield oder await Anweisung.

@alanpurple das Problem, auf das Sie sich beziehen, ist das gleiche wie das erwähnte #5404 und wird mit 4.11.1 behoben.

@itpcc Ich habe eine separate Ausgabe zu Track #5432 eröffnet. Geben Sie vorerst bitte Ihren Benutzernamen/Ihr Passwort in die URI ein: var dbURL = mongodb://${dbUser}:${dbPass}@${dbHost}:${dbPort}/${dbName}?authSource= Administrator`.

Im Allgemeinen vielen Dank an alle für Ihre Geduld beim Ausprobieren dieses neuen Verhaltens. Mir ist klar, dass das Umschalten einige Kopfschmerzen verursachen wird, weshalb wir dieses Verhalten hinter einem Flag versteckt haben, aber einige Änderungen, die für MongoDB 3.6 in die Pipeline kommen, erfordern eine vollständige Überarbeitung der internen Verbindungslogik von Mongoose. Ich hoffe, dass die neue Verbindungslogik langfristig zu weniger Mungo-spezifischen Verbindungsfehlern führen wird, aber bitte haben Sie etwas Geduld, während wir das Verhalten und die Dokumentation ausbügeln. Ihr Feedback wird sehr geschätzt.

Solange Sie auf 4.x sind, wird Ihre aktuelle Verbindungslogik funktionieren, es wird nur eine Warnung ausgegeben. In der Zwischenzeit können Sie alle Probleme, die Sie haben, in einem separaten Github-Issue melden.

Ich habe gerade die neue Methode übernommen und es funktioniert großartig. Danke an alle!

@ vkarpov15 danke für die Klarstellungen.

Zu Ihrer Information, die gleiche Verfallswarnung wird auch mit openSet ausgegeben (ich verwende einen Replikatsatz).

Zusammenfassend lässt sich sagen, dass Sie diese Warnung vorerst ignorieren können, da sie sich nur auf die interne Funktionsweise von Mongoose bezieht, und wir könnten versuchen, useMongoClient zu verwenden, müssen dies aber noch nicht.

Wie stabil ist es deiner Meinung nach? Ist es sicher zu verwenden? Ich möchte nicht 2 Stunden damit verbringen, alle unsere Modelle und Verbindungslogik zu überarbeiten, um herauszufinden, dass sie in der Produktion immer noch unbrauchbar ist.

Ist es möglich, die Verfallswarnung bis zu dem Zeitpunkt zu entfernen, an dem die Verwendung des Flags stabil ist und die empfohlene Art, eine Verbindung herzustellen, in Zukunft möglich ist? Oder ist dieser Punkt bereits erreicht?

@vkarpov15

Aber ich verwende async für createConnection. Ich habe zwei Tests gegen den DB-Server eingerichtet. Der erste ist der native mongo-js Canary-Test, um sicherzustellen, dass die URL funktioniert und ich schreiben und lesen kann:

tape('test connection via mongo native', async function testMongoConnection(t) {

  try {

    t.plan(1);
    let db = await MongoClient.connect(dbURL);
    await db.collection('users').insert({name: 'username'});
    let result = await db.collection('users').find({});
    let docs = await result.toArray();
    log.info('result', await result.toArray());
    t.equal(1, docs.length);
    db.collection('users').remove({});

    await db.close();

  } catch (err) {
  console.error(err)
  }
});

Ergebnis:

2017-07-04T09:00:34+0200 <info> atlas-api-test.js:28 (Test.testMongoConnection) result [ { _id: 595b3d1146734207bad88f9d, name: 'username' } ]
✔ should be equal

Erfolgreich durch den Mongoose-Test mit Mongoose createConnection with await:

tape('test connection via mongoose', async function testMongooseConnection(t) {

  try {
      let conn = await mongoose.createConnection(dbURL, {
        useMongoClient: true,
        /*
        // tried these settings too
        user: 'myUserName',
        pass: 'myPassword',
        connectTimeoutMS: 30000,
        rs_name: 'myReplSetName',
        ssl: true,
        auto_reconnect: true,
        */
      });

      let UserSchema = new mongoose.Schema({
        name: String,
      });

      let User = mongoose.model('User', UserSchema);
      let newUser = new User({name: 'username'});
      let createdUser = await newUser.save();

      // just ending test without validating any results
      t.end();

  } catch (err) {
    log.error(err);
  }

});

Und es wirft den folgenden Fehler:

/mypath/node_modules/mongodb/lib/replset.js:390 process.nextTick(function() { throw err; })
                                    ^
MongoError: connection 8 to cluster0-shard-00-02-c4nst.domain.com:27017 closed at Function.MongoError.create (/mypath/node_modules/mongodb-core/lib/error.js:29:11)
at Socket.<anonymous> (/mypath/node_modules/mongodb-core/lib/connection/connection.js:202:22)
at Object.onceWrapper (events.js:316:30)
at emitOne (events.js:115:13)
at Socket.emit (events.js:210:7)
at TCP._handle.close [as _onclose] (net.js:549:12)`

Ich könnte mich hier schrecklich irren, aber für mich sieht es nicht nach einem Async/Promise-Problem aus;

Ich verwende Mongo Atlas. Wenn ich {useMongoClient: true} verwende, verbindet sich meine App erfolgreich mit der Datenbank, aber die Datenbank antwortet nicht auf die Anwendung, wie?

Mein Code:
mongoose.connect(config.dbhost, {useMongoClient: true}, function(err){ if(err){ console.log(err); } else { console.log('connected to the database successfuly.'); } });

Nur ein Hinweis für alle, weil ich es hier nicht erwähnt gesehen habe: 4.11.1 wurde veröffentlicht und nach einem kurzen Blick scheint das Pufferproblem bei der Verwendung von useMongoClient=true behoben worden zu sein. Ich werde morgen weiter testen. Irgendjemand anderes?

Was ist die endgültige Lösung?

Das hat bei mir funktioniert (v.4.11.1):

Datenbank.js

mongoose.connect(databaseUri, { useMongoClient: true })
      .then(() => console.log(`Database connected at ${databaseUri}`))
      .catch(err => console.log(`Database connection error: ${err.message}`));

user.model.js

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const userSchema = new Schema({ ... });
const User = mongoose.connection.model('User', userSchema);

AKTUALISIEREN

Das Verweisen auf die Verbindung ist möglicherweise nicht erforderlich, wenn Sie Ihr Modell initialisieren (danke, @kyrylkov @peterpeterparker):

user.model.js

const User = mongoose.model('User', userSchema);

Könnte jemand kurz erklären, wofür genau { useMongoClient: true } steht oder was dieses Flag bewirkt?

Ich bin ein bisschen verloren, was ist der Vorteil, wenn ich es benutze?

Ich meine, wie ich schon sagte, ich könnte mit der Warnung leben, daher verspüre ich keine Eile, diesen Param hinzuzufügen.
Habe im Dokument nicht so viel gefunden, danke im Voraus für die Klärung.

@Blackbaud-SteveBrush Es funktioniert nicht. Ich verwende Mongo Atlas. Warum funktioniert es nicht?

@Thinkdiff

Funktioniert nicht wie? Es funktioniert für uns auf mLab und MongoDB Atlas mit dem üblichen:

const User = mongoose.model('User', userSchema);

anstatt:

const User = mongoose.connection.model('User', userSchema);

Wenn ich versuche, die useMongoClient-Option mit wenigen im URI definierten Hosts zu aktivieren, hängt sie und gibt dann einen Fehler aus:
MongoError: no mongos proxy available at Timeout._onTimeout (/home/ubuntu/code/pss/node_modules/mongoose/node_modules/mongodb-core/lib/topologies/mongos.js:636:28) at ontimeout (timers.js:386:14) at tryOnTimeout (timers.js:250:5) at Timer.listOnTimeout (timers.js:214:5) name: 'MongoError', message: 'no mongos proxy available'
uri: mongodb://10.0.1.49 ,10.0.2.158,10.0.3.84/pss
Optionen: { useMongoClient: true, autoReconnect: true, keepAlive: 300000, connectTimeoutMS: 30000 }

Für alle Interessierten finden Sie hier die Mongoose-Dokumentation zum useMongoClient -Parameter: http://mongoosejs.com/docs/connections.html#use -mongo-client

„Die standardmäßige Verbindungslogik von Mongoose ist seit Version 4.11.0 veraltet. Diese Verwerfung liegt daran, dass der MongoDB-Treiber eine API, die für die Verbindungslogik von Mongoose entscheidend ist, zur Unterstützung von MongoDB 3.6 als veraltet markiert hat. Weitere Einzelheiten finden Sie in diesem Github-Problem.“ Hier ist das GitHub-Problem: https://github.com/Automattic/mongoose/issues/5304

@Blackbaud-SteveBrush danke für den Hinweis auf unsere. Also wenn ich das richtig verstehe

useMongoClient = true => neue Verbindungslogik aktivieren, die auch mit Mongo 3.6 funktioniert
useMongoClient = false => Standardwert. alte Verbindungslogik < 4.11.0. derjenige, der veraltet ist.

rechts?

@Blackbaud-SteveBrush zu deinem Codestück, in meinem Fall verwende ich es nicht

const User = mongoose.connection.model('User', userSchema);

aber

const User = mongoose.model('User', userSchema);

und es war trotzdem erfolgreich. Vielen Dank

Mungo funktioniert bei mir 4.10.8 :|

Ich habe festgestellt, dass dies wahrscheinlich ein Fehler mit Mungo ist

Problem verschwand nach Rollback der Mongoose-Version

npm uninstall -save Mungo
npm install -save [email protected]

Ich habe diese Warnung komplett ignoriert und alles funktioniert wie erwartet. Vielleicht ist dies die Lösung für den Moment. Einfach ignorieren.

Durch das Zurücksetzen auf 4.10.8 funktionierte meine Verbindung wieder, aber ich bekomme immer noch den Fehler

Db.prototype.authenticate method will no longe against users in the admin db and will no long connect with auth credentials.

@peterpeterparker richtig. Der aktuelle Authentifizierungscode von Mongoose funktioniert nach meinem Verständnis nicht auf Mongodb 3.6, daher repräsentiert useMongoClient , dass wir versuchen, diesem Problem einen Schritt voraus zu sein und gleichzeitig die Abwärtskompatibilität aufrechtzuerhalten. Soweit ich weiß, gibt es noch keinen geplanten Veröffentlichungstermin für mongodb 3.6, daher ist die Umstellung nicht drängend.

@adamreisnz Wir hatten ein paar Fehler, aber die neue Verbindungslogik ist wirklich ein sehr dünner Wrapper um die Verwendung der Funktion MongoClient.connect() des nativen Treibers, die seit einigen Jahren die bevorzugte Methode zum Herstellen einer Verbindung mit Mongodb ist. Sobald Ihre Verbindung hergestellt ist, hält dieselbe Mongodb-Treiberlogik die Verbindung aufrecht. useMongoClient sollte sich nur auf die anfängliche Verbindung auswirken.

@vkarpov15 vielen Dank für die Erklärung und natürlich für die Arbeit, wirklich zu schätzen!

@vkarpov15 danke, ich werde es versuchen und zu useMongoClient wechseln und sehen, wohin es uns führt.

const Mungo = require("Mungo");
const db = " mongodb://localhost/testaroo ";

mongoose.connection.openUri(db);
mongoose.connection.once("open", function () {
console.log("Verbindung hergestellt");
}).on("Fehler", Funktion (Fehler) {
console.log (Fehler);
})

- Ich benutze dies und es wurden keine Fehler gefunden

var mongoose = require('mongoose');
mongoose.Promise = global.Promise;

var mongoDB = mongoose.connect('mongodb://your_database', {
    useMongoClient: true
});

mongoDB
    .then(function (db) {
        console.log('mongodb has been connected');
    })
    .catch(function (err) {
        console.log('error while trying to connect with mongodb');
    });

module.exports = mongoDB;

Ich benutze diese und keine Fehler gefunden

@vitorbarros Es hat bei mir funktioniert. Danke!

Für mich geht das:
http://mongoosejs.com/docs/connections.html#use-mongo-client

Ich habe diesen Schnelltest durchgeführt und es hat funktioniert:

// index.js
const mongoose = require('mongoose')
mongoose.Promise = global.Promise;
const db = mongoose.createConnection(`mongodb://localhost/test`)

db.on('error', err => console.log(err))
db.once('open', () => {
  console.log(`Connected to Mongo at: ${new Date()}`)
  db.close(() => {
    console.log(`Disconnected from Mongo at: ${new Date()}`)
  })
})

dann gibt mir node index.js :

Connected to Mongo at: Thu Jul 13 2017 22:54:50 GMT+0000 (UTC)
Disconnected from Mongo at: Thu Jul 13 2017 22:54:50 GMT+0000 (UTC)

Danke euch allen!

@vitorbarros deine Lösung funktioniert! Danke.

Ich kann bestätigen, dass mit 4.11.3 das Ersetzen der Verbindungslogik durch das, was @vitorbarros vorgeschlagen hat, die Warnungen entfernt und gut zu funktionieren scheint 👍

Es besteht keine Notwendigkeit, Modellverweise wie weiter oben in diesem Thread vorgeschlagen umzugestalten.

Die Lösung von @vitorbarros ist in der Tat der empfohlene Weg gemäß der Dokumentation "The useMongoClient Option" .

Beachten Sie jedoch, dass mongoose.Promise = global.Promise; den zugrunde liegenden Mongo-Treiber _nicht_ versprechen wird . Laut der Dokumentation „Promises for the MongoDB Driver“ sollte die Eigenschaft promiseLibrary auch im options-Objekt der Methode connect gesetzt werden.

Zum Beispiel:

var mongoDB = mongoose.connect('mongodb://your_database', {
    useMongoClient: true,
    promiseLibrary: global.Promise
});

global.Promise würde die native Promise-Engine verwenden. Natürlich kann auch Bluebird oder jede andere Engine verwendet werden, zB promiseLibrary: require('bluebird')

@vitorbarros Lösung funktioniert für mich. Und wir müssen auch die PromiseLibrary verwenden, wie @boaz-amit sagte.
Aber welcher Weg ist der beste für die Verwendung von Authentifizierungsdaten?
Im URL

mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]

oder besser Benutzer und Passwort in den Optionen festlegen? Ich kann im Moment keinen richtigen Ort finden.

Dies ist nur eine Möglichkeit, sich zu authentifizieren?

Und hier ist meine Lösung. Dies funktioniert auch, wenn die erste Verbindung fehlschlägt.

let firstConnectTimeout = null;
const mongoConnect = () => {
    const mongoDB = mongoose.connect('mongodb://localhost/test', {
        useMongoClient: true
    });

    mongoDB
        .then((db) => {
            clearTimeout(firstConnectTimeout);
        })
        .catch((err) => {
            firstConnectTimeout = setTimeout(mongoConnect, 5000);
        });
};

mongoConnect();

Es muss in der URL sein, die Benutzer-/Pass-Optionen funktionieren nicht mehr
useMongoClient true fand ich.

Am Montag, 17. Juli 2017, 20:28 Uhr Andrey Prisniak [email protected]
schrieb:

@vitorbarros https://github.com/vitorbarros Lösung funktioniert für mich. Und
Außerdem müssen wir die PromiseLibrary wie @boaz-amit verwenden
https://github.com/boaz-amit sagte.
Aber welcher Weg ist der beste für die Verwendung von Authentifizierungsdaten? Im URL
mongodb://[ Benutzername:Passwort@
]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
oder besser Benutzer und Passwort in den Optionen festlegen? Ich kann nicht den richtigen Ort für finden
jetzt.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/Automattic/mongoose/issues/5399#issuecomment-315694642 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/AAd8Qup1YY4lhUhQccv2kLKtraARxvP0ks5sOxs_gaJpZM4OEnIt
.

@adamreisnz @aprisniak arbeitet daran, siehe #5419. Geben Sie in der Zwischenzeit bitte den Benutzernamen und das Passwort in Ihren URI ein: mongodb://user:pass<strong i="7">@hostname</strong>:port/db

Außerdem habe ich einen Blogbeitrag über diese Option geschrieben und warum sie notwendig ist: http://thecodebarbarian.com/mongoose-4.11-use-mongo-client.html

@ vkarpov15 Ich verwende user:pass in URI, habe aber immer noch die Warnung.

Für diejenigen, die Mongoose mit gridfs-stream verwenden:

const mongooseConnect = mongoose.connect(
    process.env.MONGODB_URI || process.env.MONGOLAB_URI,
    {
        useMongoClient: true
    }
)

let gfs
mongooseConnect.then(conn => {
    gfs = Grid(conn.db)
    /** Setting up GFS storage here */
})

Mögt ihr die fehlende Verbindungsoption „useMongoClient“ bei Typescript-Typings hinzufügen und diesem Projekt stattdessen Typings zurückgeben, um Typings-Pakete hinzuzufügen.

Ich bin mir nicht sicher, ob ich etwas mit dieser Warnung tun soll oder nicht? Das wird behoben, oder?

Ich füge einfach den useMongoClient in Typings hinzu, damit es funktioniert. @iamdubx

@FinalDes wie? Ich habe mongoose.connect(process.env.DATABASE, { useMongoClient: true }) hinzugefügt, aber ich habe die Nachricht trotzdem erhalten. Und ich verwende user:pass in URI

Ein besserer Weg, um ein solches Problem zu beseitigen, ist die Verwendung dieser beiden Befehle:
npm uninstall -save Mungo
npm install -save [email protected]

NB: [email protected] ist die stabile Version.

Wie gehen Sie alle damit um, Ihr Schema und Modell zu erstellen und darauf zuzugreifen?

Ich habe alle Fixes im Thread ausprobiert. Mit der Warnung funktioniert alles einwandfrei. Sobald ich useMongoClient: true oder mongoose.createConnection versuche, wird die Warnung entfernt und ich kann eine Verbindung zur Datenbank herstellen, aber jeder Code, der versucht, auf das Modell zuzugreifen, wird nicht ausgelöst. Es gibt keine Fehler, der Code wird einfach nie ausgeführt.

@iamdubx
Es fehlen nur die Eingaben. Wenn Sie also mit "noImplicitAny": true ausgeführt werden, tritt kein Fehler auf

import mongoose = require("mongoose");
import dotenv = require("dotenv");
dotenv.config();
Mungo.Versprechen = global.Versprechen;
const MONGO_URI=`mongodb://${process.env.MONGODB_HOST}:${process.env.MONGODB_PORT}/${process.env.MONGODB_DB}`;
mongoose.connect(MONGO_URI, {
useMongoClient: wahr,
});

@FinalDes worauf beziehst du dich? Welche fehlenden Eingaben? Ich habe den gleichen Code oben und habe einen Fehler.

Ich habe das gleiche Problem mit @Snow-Okami festgestellt

1. const mongoDB = mongoose.connect(config.database, { useMongoClient: true });
   Dies beseitigt die Warnung und verbindet sich mit der db. Jedoch scheitert alles, was versucht, auf das Modell zuzugreifen (get/post). Es wird kein Fehler zurückgegeben.
2. const mongoDB = mongoose.connect(config.database, function(){ useMongoClient: true });
   Und das gibt diese beiden Warnungen, aber alles andere als das funktioniert gut.

Bitte geben Sie zumindest die Abwärtskompatibilität an, wenn unser Produktions-Build-Server fehlschlägt.
Funktionsaktualisierung ist gut, aber ändern Sie die Methodensignatur oder den Aufruf nicht.

@Nikunjksanghavi Es ist nur eine Warnung, nichts sollte fehlschlagen.

@iamdubx was für ein Fehler?

@FinalDes Verwerfungsfehler, worüber sprechen wir sonst noch in diesem Thema?

Das hat bei mir funktioniert: (v.4.11.4)

const MONGO_URI = process.env.MONGO_URI
const mongoose = require('mongoose');

// Use your own promis library
mongoose.Promise = require('bluebird');

// connect to mongo, use Mongo Client
mongoose.connect(MONGO_URI, {useMongoClient: true})
  .then(({db: {databaseName}}) => console.log(`Connected to ${databaseName}`))
  .catch(err => console.error(err));

const poemSchema = mongoose.Schema({
    name: String,
    text: String
});

const Poem = mongoose.model('Poem', poemSchema);

const insertPoem = poem =>
  (new Poem(poem)).save( (err, newPoem) => 
    console.log(err || newPoem));

insertPoem({name: 'poemName', text: 'this is a poem'})

// DB-Verbindung
var Mungo = require('Mungo');
Mungo.Versprechen = global.Versprechen;
mongoose.connect('mongodb://localhost/login_register', {
useMongoClient: wahr
})
.then(() => console.log('Verbindung erfolgreich'))
.catch((err) => Konsole.Fehler(err));
// Ende der DB-Verbindung

Das funktioniert bei mir nicht. Ich habe immer noch eine Konsolenwarnung. Und keine klare Erklärung liefern.

Mungo ist schrecklich. Auch die schlechteste Dokumentationsseite, die ich in so beliebten Bibliotheken gesehen habe. Schade!

Jetzt überlege ich, zu RethinkDB zu wechseln. Linux Foundation - das ist ernst.
Auch Postgre genial.

Mongo - sehr, sehr schade.

@iamdubx hast du meine Lösung oben ausprobiert? Könntest du die Warnung hier einfügen? Vielleicht konnte ich helfen :)

@iamdubx kann deine Warnmeldung posten?

@FinalDes @shams-ali Ich habe zuvor gepostet, es ist der gleiche Verwerfungsfehler wie im Thema. Der, um den es in diesem Thema geht!

(node:3304) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, or set the `useMongoClient` option if using `connect()` or `createConnection()`. See http://mongoosejs.com/docs/connections.html#use-mongo-client
Server listening on port: 7777
Db.prototype.authenticate method will no longer be available in the next major release 3.x as MongoDB 3.6 will only allow auth against users in the admin db and will no longer allow multiple credentials on a socket. Please authenticate using MongoClient.connect with auth credentials.

@iamdubx interessant, das ist die gleiche Warnung, die ich hatte, und die obige Lösung, die ich gepostet habe, schien sie für mich zu beheben. Könnten Sie Ihren aktualisierten Code einfügen, der nicht funktioniert?

Das hat bei mir funktioniert:

// ES6 promises
mongoose.Promise = Promise;

// mongodb connection
mongoose.connect("mongodb://localhost:27017/sandbox", {
  useMongoClient: true,
  promiseLibrary: global.Promise
});

var db = mongoose.connection;

// mongodb error
db.on('error', console.error.bind(console, 'connection error:'));

// mongodb connection open
db.once('open', () => {
  console.log(`Connected to Mongo at: ${new Date()}`)
});

@afoke funktioniert danke

@FinalDes Gern geschehen , Kumpel.

Dies ist mein neuer Workflow, der versucht, die Warnungen und Ablehnungen einzuhalten:

// db.js
const model = require('./model');
const mongoose = require('mongoose');
mongoose.Promise = global.Promise;


async function db(uri) {
  const con = await mongoose
    .createConnection(uri, {
      useMongoClient: true,
    });

  const {User} = model(con);

  // do something with User
  ...

  // the interface for the server
  return {
    create: params => User.create(params),
    ...
  };
}


module.exports = db;

Und jetzt gibt das Models-Modul eine Verbindungsfunktion zurück

// model.js
const {Schema} = require('mongoose');


const UserSchema = new Schema({
  name: String,
  age: Number,
});

// Other Schemas
...

module.exports = con => ({
  User: con.model('User', UserSchema),
  ...
});

Irgendwelche offiziellen Richtlinien zu diesem Thema?

@iamdubx Klingt so, als würden Sie den Unterschied zwischen einer Warnung und einem Fehler nicht verstehen.

Die fragliche Warnung beschädigt nichts, warnt den Benutzer jedoch vor etwas, das in der nächsten Hauptversion entfernt wird.

Mungo ist schrecklich.

Denken Sie also daran, dass Sie diese Reaktion darauf haben, dass die Entwickler Sie im Voraus warnen, bevor sie eine Funktion entfernen. Ich möchte Sie auch dringend bitten, daran zu denken, dass Sie dies kostenlos verwenden, also geben Sie den Entwicklern vielleicht den Vorteil des Zweifels, bevor Sie einen Wutanfall bekommen

@chrisdothtml

Die fragliche Warnung beschädigt nichts, warnt den Benutzer jedoch vor etwas, das in der nächsten Hauptversion entfernt wird.

Es verschmutzt Tests und Konsolen, was leicht nervig ist.

Mungo ist schrecklich. Auch die schlechteste Dokumentationsseite, die ich in so beliebten Bibliotheken gesehen habe. Schade!

Er ist unhöflich, was auch leicht nervig ist, aber er macht einen sehr gültigen Punkt in Bezug auf die Mongoose-Dokumentation. Es ist nicht die schlechteste Dokumentation aller Zeiten, aber sie könnte wirklich verbessert werden.

Die Tatsache, dass Mongoose die Mongo-Client-API weiterleitet. was auf eine ganz andere Weise funktioniert, macht die Verwendung und Dokumentation von Mongoose verwirrend.

Eine mögliche Lösung hierfür wäre:

• hör auf damit
• Entfernen Sie die Dokumentation für die Mongo-Client-Methoden
• bieten eine Möglichkeit, die Verbindung zwischen dem offiziellen Client und Mongoose zu teilen

Ich würde auch vorschlagen, die Durchsuchbarkeit von Dokumenten zu verbessern, indem Sie sie auf mehrere Seiten aufteilen und neuen Benutzern mehr Einblick darüber geben, was Mongoose tatsächlich tut, um einige der Ergebnisse zu erzielen.

Ich hatte diesen Fehler, aber er verschwand, nachdem ich die Option {useMongoClient: true} hinzugefügt hatte.
Ich verwende Debian 9, Testversion, mit MongoDb ver. 3.2.11 und Mongoose Ver. 4.10.4.
Ich habe die Nachricht „Connected to MongoDB“ (siehe Code in Typescript unten), alles funktioniert perfekt.

(< irgendein >Mungo).Promise = global.Promise;
mongoose.connect(process.env.MONGODB_URI, {useMongoClient: true});
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('öffnen', () => {
console.log('Mit MongoDB verbunden');
setRoutes (App);
app.get('/*', function(req, res) {
res.sendFile(path.join(__dirname, '../public/index.html'));
});
app.listen(app.get('port'), () => {
console.log('MyApp hört auf Port ' + app.get('port'));
});
});

Deinstallieren Sie einfach die aktuelle Mongoose-Version, die Sie haben, und installieren Sie die niedrigere Version npm install [email protected] --save . Sie müssen nichts weiter tun, dies wird definitiv für Sie funktionieren.

mongoose.connect(database.host, { useMongoClient: true });

Dies löste mein Problem. Aber ich hatte eine weitere Warnung, nachdem ich diese Änderung vorgenommen hatte.

DeprecationWarning: Mongoose: mpromise (die standardmäßige Promise-Bibliothek von Mongoose) ist veraltet, schließen Sie stattdessen Ihre eigene Promise-Bibliothek an: http://mongoosejs.com/docs/promises.html

Dieser Code löst alle Verfallswarnungen:
``` Javascript
Mungo.Versprechen = global.Versprechen;
mongoose.connect(uri, {
keepAlive: wahr,
reconnectTries: Number.MAX_VALUE,
useMongoClient: wahr
});
````
Weitere Informationen unter dem Link -> http://mongoosejs.com/docs/connections.html#use -mongo-client

@bricss Fantastisch! Danke!

@bricss Du hast meinen Tag gerettet.

Jemand hat sich ein Heldenabzeichen verdient...

Bearbeiten: @bricss Es hat die Verfallswarnungen für mich beseitigt, aber ich konnte keine Daten aus meinen mlab-Sandboxen abrufen. Dies kann daran liegen, dass sie eine ältere Version von MongoDB verwenden. Ich werde versuchen, es später zu überprüfen.

Bearbeiten: @bricss Es funktioniert jetzt korrekt mit dem neuesten Mungo 4.11.9 und einer Verbindung zu Cosmos DB auf Azure.

@bricss : Gut gemachte Steine! Es hat bei mir funktioniert, obwohl ich eine wirklich alte Version von Mongodb in meinem lokalen :+1:

@bricss Ehrfürchtig! Aber Sie könnten erwägen, eine kleinere Zahl für "reconnectTries" einzugeben. Sie möchten nicht den ganzen Tag damit verbringen, die Verbindung wiederherzustellen, wenn es ein Problem mit Ihrer DB gibt.

Die Lösung von @afoke hat bei mir funktioniert, nur wenn ich die Datenbank explizit in der Verbindungszeichenfolge deklariere, dh mongodb://localhost:27017/test , aber nicht mongodb://localhost:27017

Kann ich ohne diese Warnung eine Verbindung zu 2 DBs herstellen? Ich muss meine Modelle mit verschiedenen DBs verwenden.

Unter Verwendung von Mongoose v^4.11.6 verschwand die Warnung, wenn useMongoClient hinzugefügt wurde.

const uri = "http://blablabla.blo/blaDB"; mongoose.Promise = global.Promise; mongoose.connection.on('error', (err) => { console.error( Mungo-Verbindungsfehler: ${err}`);
process.exit(1);
});
mongoose.connect(uri, {useMongoClient: true});

 // load models
 require('./model1');
 // ...
 require('./modelN');`

Das Verbinden mit der Datenbank auf diese Weise löst das Problem:
mongoose.connect(url,{user:'username',pass:'mypassword',useMongoClient:true});

Werden diese Fehler Probleme verursachen, zum Beispiel bei der Sicherheit?

Es erscheint keine „veraltet“-Warnung mehr, wenn ich diese Syntax verwende 🎉

mongoose.connection.openUri('mongodb://localhost/test')
  .once('open', () => console.log('Good to go !'))
  .on('error', (error) => {
    console.warn('Warning', error);
  });

Ich sah mich der gleichen Abwertungswarnung wie unten gegenüber:
(node:2300) DeprecationWarning: open() ist in Mongoose >= 4.11.0 veraltet, verwenden Sie stattdessen openUri() oder setzen Sie die Option useMongoClient , wenn Sie connect() verwenden oder createConnection() . Siehe http://mongoosejs.com/docs/connections.html#use -mongo-client

Lösung

Ich habe folgendes ausprobiert und es funktioniert gut. Gibt keine Verfallswarnungen aus.

mongoose.connect('mongodb://127.0.0.1:27017/your-database-name', { useMongoClient: true, promiseLibrary: global.Promise });

Ich hoffe, dies wird allen helfen, die mit diesem Problem konfrontiert sind.

Ich habe das gleiche Problem, aber wenn ich versuche, eine Verbindung zum Mongo Atlas-Dienst herzustellen, wird einfach keine Verbindung mit der Option {useMo ngoClient:true } hergestellt, und ohne sie wird die Verbindung nicht mehr ausgeführt.

Jemand mit dem gleichen Problem?

Ich hatte mein Problem gelöst, indem ich einfach die mongoose.connect in mongoose.createConnection geändert hatte

mongoose.createConnection(config.uri, (err) => {
wenn (fehler) {
console.log('Konnte KEINE Verbindung zur Datenbank herstellen: ', err);
} anders {
console.log('Mit Datenbank verbunden: ' + config.db);
}
});

Ich habe dieses Problem so gelöst (Mongoose 4.12.0, NodeJS - 7.10.1)

mongoose.Promise = require('bluebird');
mongoose.connect('mongodb://localhost:27017/books_exchange', {
  useMongoClient: true,
  promiseLibrary: require('bluebird')
}).then(() => {
  var userSchema = new mongoose.Schema({
    name: String,
    password: String
  });
  var User = mongoose.model('User', userSchema);

  var person = new User({
    name: "John",
    password: "qwerty"
  });

  person.save().then(() => {
    console.log('Data saved');
  }).catch(e => {
    console.log(e);
  });
}).catch(e => {
  console.log('Error while DB connecting');
  console.log(e);
});