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

Erstellt am 25. Juni 2017  Â·  158Kommentare  Â·  Quelle: Automattic/mongoose

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

Mongoose 4.11.0, MongoDB 2.2.29, NodeJS 8.1.2

Hilfreichster Kommentar

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.

Alle 158 Kommentare

+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);
});
War diese Seite hilfreich?
0 / 5 - 0 Bewertungen

Verwandte Themen

p3x-robot picture p3x-robot  Â·  3Kommentare

Igorpollo picture Igorpollo  Â·  3Kommentare

ghost picture ghost  Â·  3Kommentare

jeneser picture jeneser  Â·  3Kommentare

weisjohn picture weisjohn  Â·  3Kommentare