Mongoose: पदावनति चेतावनी: 'ओपन ()' को नेवला> = 4.11.0 में पदावनत किया गया है, इसके बजाय 'ओपनयूरी ()' का उपयोग करें

+1, मुझे नहीं पता कि उस चेतावनी से छुटकारा पाने के लिए कहां ठीक करना है

चेतावनी वास्तव में Mongoose के अंदर एक कोड के लिए है, जब कनेक्टिंग स्ट्रिंग में एक प्रतिकृति सेट होता है:

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

तो फिर, यह एक बग है?

एक बग की तरह दिखता है, क्या हम विकल्पों में useMongoClient: true जोड़कर समाधान कर सकते हैं (आप तब MongoDB ड्राइवर से एक पदावनति देख सकते हैं, लेकिन वह फेंकता नहीं है)

useMongoClient: true जोड़ने से संदेश गायब हो जाता है, लेकिन फिर मेरे दस्तावेज़ लोड होना बंद हो जाते हैं। इसे गहराई से डिबग नहीं किया है, लेकिन मैं अपना कोड अनुकूलित करने से पहले सर्वोत्तम प्रथाओं को सुनना पसंद करूंगा।

मेरा आवेदन भी ऊपर सुझाए गए समाधान के साथ काम नहीं करता है। यह अब MyModel.find विधि नहीं चलाता है और कोई त्रुटि नहीं देता है और कोई टाइमआउट नहीं देता है।

अधिकांश मामलों के लिए "useMongoclient: true" विकल्प काम नहीं करने का कारण उस विकल्प के लिए है, प्रत्येक नेवला कनेक्शन-संबंधित ऑब्जेक्ट डमी ऑब्जेक्ट देता है जो मोंगोडब तक पहुंचने में सक्षम नहीं है

मैंने इसे इस तरह इस्तेमाल करने की कोशिश की

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

लेकिन यह काम नहीं करता

प्रतिकृति सेट के बिना भी एक ही समस्या है।

एक ही समस्या होना:

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

वैसा ही...

मेरे मोंगो कनेक्शन में नीचे दिए गए कोड को जोड़ने के बाद, मैं अब कुछ भी नहीं पूछ सकता।
{यूजमोंगो क्लाइंट: सच}।
किसी भी सुझाव की सराहना की जाएगी !!

प्रतिकृति सेट के साथ +1 समान, कोई शार्डिंग नहीं

+1

+1

+1

+1

+1

+1

+1

इसके लिए सबसे आसान फिक्स; " npm remove mongoose " फिर " npm install [email protected] --save " समस्या हल हो गई। अपग्रेड करना हमेशा सबसे अच्छा विकल्प नहीं होता है।

+1

+1

मुझे 2 संदेश मिलते हैं:

(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.

पहली त्रुटि 4.11.0 में दिखाई दी। दूसरी त्रुटि नेवला के पिछले संस्करण में भी दिखाई दी।

plhosk, दूसरा 4.11 में तय किया जाना चाहिए था, लेकिन ऐसा लगता है कि यह अभी भी है, मेरे लिए भी।

+1

+1 दुख की बात है।

बिना किसी समस्या के 4.10.8 स्थापित किया। कृपया npm install mongoose --save को डिफ़ॉल्ट से 4.10.8 में बदलने पर विचार करें जब तक कि 11 स्थिर न हो जाए।

+1

+1

+1

+1

मुझे यह मुद्दा भी मिला।
__नोड संस्करण__: v6.10.0

__MongoDB__ वातावरण: (मैं मोंगो डॉकटर कंटेनर के नवीनतम संस्करण पर चला)

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" } }

मेरा कनेक्शन विन्यास:

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

जब मैं झूठा होने के लिए useMongoClient का उपयोग करता हूं। नेवला निम्नलिखित चेतावनियाँ दिखाता है:

(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.

लेकिन यह ठीक काम करता है।

हालांकि, जब मैंने इसे true पर सेट किया, तो मुझे यह त्रुटि मिली:

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)

मैं कनेक्शन यूआरएल से भी authSource=admin को हटाने की कोशिश करता हूं, लेकिन यह अभी भी काम नहीं करता है

(नोड: 451) पदावनति चेतावनी: open() नेवला में पदावनत है >= 4.11.0, उपयोग
इसके बजाय openUri() , या useMongoClient विकल्प सेट करें यदि connect() या createConnection() उपयोग कर रहे हैं
Db.prototype.authenticate विधि अब अगले प्रमुख पुन: में उपलब्ध नहीं होगी
लीज 3.x क्योंकि MongoDB 3.6 केवल व्यवस्थापक db और w . में उपयोगकर्ताओं के विरुद्ध प्रमाणीकरण की अनुमति देगा
बीमार अब सॉकेट पर एकाधिक प्रमाण-पत्रों की अनुमति नहीं देता है। कृपया M . का उपयोग करके प्रमाणित करें
ongoClient.connect प्रामाणिक क्रेडेंशियल के साथ।

मुझे यह समस्या नेवला संस्करण 4.11.0 और MongoDB संस्करण 3.4.5 . के साथ मिलती है

+1

+1

उपयोग

mongoose.createConnection(URI)

@nandofalcao उपयोग करते समय:

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

जाहिरा तौर पर मैं नए रिकॉर्ड नहीं बचा सकता।

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

आज रात पॉलीग्लॉट जोड़ना और +1 इसका अनुभव करना।

// 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

और मुझे दूसरा संदेश मिलता है:

[2017-06-27 16:14:23.702] [सूचना] :: - सर्वर 2000 पोर्ट में शुरू हुआ

(नोड:1193) पदावनति चेतावनी: open() नेवला में पदावनत है >= 4.11.0, इसके बजाय openUri() का उपयोग करें, या connect() का उपयोग करने पर useMongoClient विकल्प सेट करें या createConnection()

Db.prototype.authenticate विधि अब अगली प्रमुख रिलीज़ 3.x में उपलब्ध नहीं होगी क्योंकि MongoDB 3.6 केवल व्यवस्थापक db में उपयोगकर्ताओं के विरुद्ध प्रमाणीकरण की अनुमति देगा और अब सॉकेट पर एकाधिक क्रेडेंशियल की अनुमति नहीं देगा। कृपया प्रामाणिक क्रेडेंशियल के साथ MongoClient.connect का उपयोग करके प्रमाणित करें।

+1

+1

+1

+1

+1

क्या कोई इसे बेकार +1 को रोकने के लिए लॉक कर सकता है?

इस थ्रेड के सदस्यों के सौजन्य से, कृपया +1 के साथ उत्तर देना बंद करें क्योंकि यह बेकार ईमेल सूचनाएं उत्पन्न करता है। यह एक मंच नहीं है। यदि आप इस धागे का अनुसरण करना चाहते हैं, तो दाहिने साइडबार पर सदस्यता लें बटन का उपयोग करें। आप स्वयं भी कुछ शोध कर सकते हैं और समाधान में योगदान कर सकते हैं।

मैंने संस्करण को वापस 4.10.8 में बदल दिया और अब यह ठीक काम कर रहा है।

ऐसा लगता है कि ValYouW के पास यहां दस्तावेज़ लोड करने की समस्या का संभावित समाधान है: #5404

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

क्या किसी ने यह कोशिश की है? जब मैं इसका उपयोग करता हूं तो मेरी बहिष्कृत चेतावनी गायब हो जाती है, यह दस्तावेज़ीकरण से थी

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

@crisamdegracia जो मानता है कि आपके पास पहले से ही एक कनेक्शन है

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

जो हम नहीं करते (कम से कम मुझे जब से मैं mongoose.connect विधि का उपयोग करके mongodb से कनेक्ट करता था)

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

मुझे कोई दस्तावेज़ नहीं मिला... क्या ग़लत है?

+1

तो @phased90 से जुड़े मुद्दे को देखने के बाद जो बताता है कि आप इस तरह से जुड़ सकते हैं:

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

मैंने कोड के माध्यम से एक त्वरित गोता लगाया और ऐसा प्रतीत होता है कि 4.11 MongooseThenable देता है सिवाय इसके कि जब {useMongoClient: true} विकल्प प्रदान किया जाता है। उस उदाहरण में यह Connection.prototype.openUri पर कॉल करता है जो Promise.ES6 का एक नया उदाहरण देता है। क्या उस Connection.prototype.openUri कॉल को MongooseThenable में लपेटा जाना चाहिए?

प्रश्न के लिए मेरी क्षमायाचना, यह मेरा पहली बार इस कोडबेस को देख रहा है इसलिए मैं थोड़ा अनिश्चित हूं। लेकिन अगर Moongoose.prototype.connect को हमेशा MongooseThenable का उदाहरण लौटाना चाहिए, तो मुझे कुछ स्पष्टीकरण मिल सकता है, तो मुझे एक फिक्स प्रदान करने में मदद करने में खुशी होगी।

ध्यान रखें कि {useMongoClient: true} का उपयोग करने से $ Connection.prototype.openUri को कॉल किया जाएगा, जो बफ़र्ड कमांड को ट्रिगर नहीं करता है जो __before__ #5404 के कारण DB से कनेक्ट होने से पहले बनाए गए थे।

+1

क्षमा करें, चीजें पागल हो गई हैं, थोड़ी देर में देख लेंगे।

@varunjayaraman को सॉरी फ्रेंड होने की जरूरत नहीं है। लोग या तो प्रतीक्षा कर सकते हैं, या इसे स्वयं ठीक करने का प्रयास कर सकते हैं।

+1

तो खोले गए वास्तविक मुद्दे के संबंध में, बहिष्करण चेतावनी एक बग नहीं है, यह सिर्फ एक चेतावनी है: नेवला अपने वर्तमान कनेक्शन तर्क को बहिष्कृत करने जा रहा है, इसलिए आपको useMongoClient परम में पास होना चाहिए। यह प्रलेखन में पाया जा सकता है

एक अलग नोट पर, ऐसा लगता है कि यह एक पीछे की ओर तोड़ने वाला परिवर्तन था, उम्मीद है कि इसे अगली छोटी रिलीज में तय किया जा सकता है (या शायद ऐसा नहीं है, मैं यहां बहुत कम नींद पर चल रहा हूं):

यह सामान्य रूप से काम करेगा ( useMongoClient भाग के लिए सहेजें, जो नया है):

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

ऐसा लगता है कि यह मेरे लिए एक त्रुटि फेंक रहा है क्योंकि db.model अब एक फ़ंक्शन नहीं है।

mongoose.model का उपयोग करते समय, यह काम करता है:

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 मैंने अभी Mongoose को अपडेट किया है और आपके सुझाव के अनुसार useMongoClient: true का उपयोग किया है, लेकिन मुझे एक समस्या है।
यह आधिकारिक Mongoose प्रलेखन के अनुसार, user , और pass विकल्पों का समर्थन नहीं करता है:

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

और, हाँ, प्रमाणित करने में विफल रहा। :-1:

मैं उपयोगकर्ता को जोड़ने और इसके बजाय कनेक्शन स्ट्रिंग में पास करने का प्रयास करूंगा।
यह तब काम करता है जब मैं कनेक्शन स्ट्रिंग में उपयोगकर्ता नाम और पासवर्ड जोड़ता हूं। शायद आपको दस्तावेज़ीकरण अपडेट करना चाहिए। मैं

@itpcc 4.10.8 संस्करण का उपयोग करने का प्रयास इस समय सबसे अच्छा समाधान है।

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

साभार: @ चेन्ज़62

@CQBinh आपकी सलाह के लिए धन्यवाद। मैं इसके बारे में उन टिप्पणियों को पहले ही पढ़ चुका हूं।
हालाँकि, मुझे नहीं लगता कि पुराने संस्करण का उपयोग करना अभी के लिए सबसे अच्छा समाधान है। और यह कनेक्शन स्ट्रिंग में डालने से हल कर सकता है।
मैं सिर्फ भ्रमित महसूस करता हूं क्योंकि दस्तावेज़ में इसका उल्लेख किया गया था लेकिन यह काम नहीं करता है। :/
बीटीडब्ल्यू, मैं यहां एक नए मुद्दे के रूप में रिपोर्ट करता हूं

@varunjayaraman अगर db.model अब मौजूद नहीं है, तो कोई अलग-अलग मॉडलों के साथ कई अलग-अलग नेवला कनेक्शन कैसे संभालेगा?

उदाहरण के लिए मॉडल1 और मॉडल2 नेवलाकनेक्शन1 से जुड़े और मॉडल3 और मॉडल4 नेवलाकनेक्शन2 से जुड़े।

पहले यह प्रत्येक कनेक्शन के लिए mongoose.createConnection पर कॉल करके और इन रिटर्न मानों में से प्रत्येक के लिए मॉडल संलग्न करके किया जाता था।

संपादित करें: या यह अभी भी इस मामले में काम कर रहा है:

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

+1

@ Boyce-ywr गंभीरता से, एक और +1 ??? आप लोगों का क्या कसूर है??
रचनात्मक टिप्पणियां पोस्ट करें, इस तरह की चीजें नहीं।

नेवले के संबंध में, यह मेरे लिए स्पष्ट नहीं है कि भविष्य के रिलीज में mongoose.connect() पद्धति को प्रतिस्थापित किया जाएगा या नहीं। कृपया कोई समझा सकता है?

@simonemazzoni आप सही कह रहे हैं, वे हमें स्पैम कर रहे हैं।

यदि आप इस थ्रेड के लिए सूचनाओं में शामिल होना चाहते हैं, तो आपको केवल इसकी सदस्यता लेने की आवश्यकता है (थ्रेड के शीर्ष पर एक बटन है),

जब आप +1 करते हैं तो आप केवल यह कहते हुए सभी को यहां एक ईमेल भेजते हैं

हैलो मैं यहां हूं!

हमें परवाह नहीं है , हम रचनात्मक टिप्पणियों और समाधान की प्रतीक्षा कर रहे हैं।

इसके अलावा, आप सभी +1 इस सूची से अपनी पोस्ट को हटा क्यों नहीं देते हैं, वे एक आंखों के दर्द और पीछे के दर्द हैं जिन्हें वास्तविक टिप्पणियों तक पहुंचने के लिए केवल अतीत को स्क्रॉल करना पड़ता है।

जैसा कि कुछ लोगों ने पहले कहा, एकमात्र "समाधान" [email protected]_ पर वापस जाना है ...
कम से कम अभी के लिए!

एक बग की तरह लग रहा है, समस्या को हल करने के लिए [email protected] पर वापस चला गया

mongoose.connect(...) के बजाय mongoose.createConnection(...) का उपयोग करें।

यहाँ @diegoazh की अनुशंसा के आधार पर [email protected] का उपयोग करने का एक पूर्ण कार्य उदाहरण दिया गया है

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 तो हम सिर्फ कनेक्ट ड्रॉप करते हैं और इसके बजाय createConnection का उपयोग करते हैं?

@ bertolo1988 जैसे पीपीएल ने इस मुद्दे पर सुझाव दिया था, वर्तमान में दो समाधान हैं

1. 4.10.8 . पर वापस आएं
2. यदि आप नए संस्करण के साथ रहना पसंद करते हैं तो नए पैटर्न का उपयोग करें

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

मैं व्यक्तिगत रूप से दूसरा समाधान पसंद करता हूं।

धन्यवाद!!!
createConnection द्वारा हल किया गया है, और मॉडल बनाने के लिए उस कनेक्शन का उपयोग करें (मोंगोज़ के बजाय)

let mongoose = require('mongoose');

mongoose.Promise = global.Promise;

module.exports = mongoose;

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

नए कनेक्शन पैटर्न के लिए कुछ कोड परिवर्तनों की आवश्यकता होती है, और आपके प्रोजेक्ट के आकार के आधार पर जिसका अर्थ बहुत समय हो सकता है और शायद आर्किटेक्चर में भी बदलाव हो सकता है (इस तथ्य को देखते हुए कि मॉडल बनाने के लिए कनेक्शन की आवश्यकता होती है)।

यह बहुत अच्छा होता अगर पुराना कनेक्शन मॉडल नए कनेक्शन मॉडल को लपेट सकता।

बहुत सारी पोस्ट हैं, इसलिए क्या मैं संक्षेप में बताने की कोशिश कर सकता हूं:

1. चेतावनी एक पदावनत चेतावनी है, जिसका अर्थ है, कोई जल्दी नहीं है। अगर हम कुछ भी नहीं बदलते हैं तो यह हमेशा की तरह काम करेगा, सब कुछ ठीक लगता है

2. चेतावनी के अनुसार, कनेक्ट() को संशोधित किया जा रहा है/किया गया है और उपयोग करना मोंगो क्लाइंट एक जरूरी होगा। लेकिन यहां संभावित बग/समस्या है

• कनेक्ट ('myurl', {useMongoClient: true}) => दस्तावेज़ लोड करना बंद कर देता है और डीबी में लिखना संभव नहीं है

• कनेक्ट ('myurl', {useMongoClient: false}) => ठीक काम करता प्रतीत होता है लेकिन चेतावनी अभी भी प्रदर्शित होती है

इसलिए इस मुद्दे का उद्देश्य विधि कनेक्ट की कॉल के मामले में useMongoClient के उपयोग को सही करना है।

इस बात से सहमत?

फिर भी, जबकि एक बहिष्करण चेतावनी वास्तव में "सिर्फ" चेतावनी है, उस शो के होने से मुझे आश्चर्य होता है कि इसे वास्तव में कब हटाया जा रहा है। अगर नेवला सीवर का अनुसरण कर रहा है, तो यह अभी भी 4.x शाखा में होना चाहिए। इसलिए, इसे तब भी पश्चगामी संगतता के साथ काम करना चाहिए जब तक कि 5.x जारी न हो जाए।

परिवर्तन के संबंध में, यह एक तरह से कष्टप्रद है कि मुझे इस परिवर्तन के बारे में कुछ भी जल्दी से नहीं मिला, सिवाय इसके कि चैंज में उल्लेख किया गया है। और यहां तक ​​कि जब आप इसे बदलते हैं, तब भी सामान टूट जाता है और यहां कई लोगों के अनुसार, यह .model() कॉल के कारण है।

साथ ही, यहां तक ​​कि दस्तावेज़ अभी भी mongoose.connect() और mongoose.model() दिखाते हैं, जो इस मामले को और भी भ्रमित करता है। mongoose.connect() परिवर्तन का उल्लेख केवल कनेक्शन पूल के अंतर्गत किया गया है, न कि इस पृष्ठ के अन्य भागों पर। तो सवाल यह है कि क्या यह बदलाव एक बग है, या इरादा है?

मुझे नहीं पता कि यह कहां जा रहा है, लेकिन मैंने इस सप्ताहांत के बेहतर हिस्से को मोंगोडीबी के एटलस में कनेक्शन प्राप्त करने की कोशिश में बिताया है। देशी मोंगोडब चालक तुरंत सीआरयूडी सामान चला रहा था।

हालाँकि नेवले को पाने की कोशिश करना कुल दुःस्वप्न है। अगर मैं 4.11 के साथ createConnection का उपयोग करता हूं तो क्लस्टर कनेक्शन मारे जाते हैं:

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

वैकल्पिक रूप से, मैं सेट कर सकता था

useMongoClient: true

लेकिन फिर मैं कनेक्शन पर अपरिभाषित हो जाता हूं। मॉडल

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

@Archomeda 4.x में विरासत कनेक्शन व्यवहार को हटाने की कोई योजना नहीं है, और 5.x स्थिर स्थिति में नया कनेक्शन तर्क प्राप्त करने पर अवरुद्ध है। कनेक्शन डॉक्स पर ऐसे दस्तावेज़ हैं जो 4.11.1 में सुधार करेंगे और उससे लिंक सहायक होना चाहिए। पुन: model() कॉल, यदि आप useMongoClient: true निर्दिष्ट करते हैं, तो createConnection() एक कनेक्शन नहीं लौटाएगा, बल्कि एक वादा जो उस कनेक्शन को हल करता है जिसकी आपको आवश्यकता है .then() चालू। तर्क का वर्णन यहाँ किया गया है: https://github.com/Automattic/mongoose/issues/5404#issuecomment -312522539 कृपया इस बारे में किसी भी चिंता को #5404 अंक पर व्यक्त करने के लिए स्वतंत्र महसूस करें।

@mkastner ऐसा लगता है कि आप createConnection() का उपयोग कर रहे हैं। useMongoClient: true के साथ, createConnection() एक वादा देता है जो एक कनेक्शन को हल करता है। कृपया await mongoose.createConnection() या mongoose.createConnection().then() उपयोग करें

@peterpeterparker #5404 ने नए कनेक्शन तर्क के साथ एक समस्या की ओर इशारा किया जिसे अगले 24 घंटों के भीतर जारी करने के लिए 4.11.1 में तय किया जाएगा।

@ cosminn777 आपके पास कौन से वास्तुशिल्प मुद्दे हैं? कृपया उन पर चर्चा करने के लिए एक अलग मुद्दा खोलें। लंबी अवधि की योजना यह है कि 5.x में हम नोड <4 का समर्थन नहीं करेंगे, इसलिए नेवले का उपयोग करने वाले सभी लोगों के पास जनरेटर और/या async/प्रतीक्षा करने के लिए मूल पहुंच होगी, इसलिए यह परिवर्तन yield जोड़ने जितना आसान होगा। await स्टेटमेंट।

@alanpurple जिस मुद्दे का आप जिक्र कर रहे हैं वह वही है जिसका उल्लेख # 5404 है और इसे 4.11.1 के साथ ठीक किया जाएगा।

@itpcc मैंने #5432 को ट्रैक करने के लिए एक अलग मुद्दा खोला। अभी के लिए, कृपया अपना उपयोगकर्ता नाम/पासवर्ड URI में डालें: var dbURL = mongodb://${dbUser}:${dbPass}@${dbHost}:${dbPort}/${dbName}?authSource= व्यवस्थापक `.

सामान्य तौर पर, इस नए व्यवहार को आज़माने में आपके धैर्य के लिए सभी का धन्यवाद। मुझे एहसास है कि स्विच करने से कुछ सिरदर्द होगा, यही वजह है कि हमने इस व्यवहार को एक झंडे के पीछे छिपा दिया, लेकिन कुछ बदलाव MongoDB 3.6 के लिए पाइप के नीचे आ रहे हैं, नेवले के आंतरिक कनेक्शन तर्क के पूर्ण ओवरहाल की आवश्यकता है। मुझे उम्मीद है कि नया कनेक्शन तर्क लंबे समय में कम नेवला-विशिष्ट कनेक्शन बग को जन्म देगा, लेकिन कृपया हमारे साथ रहें क्योंकि हम व्यवहार और दस्तावेज़ीकरण को दूर करते हैं। आपकी प्रतिपुष्टियों के लिए के लिए हम बहुत आभारी हैं।

जब तक आप 4.x पर हैं, आपका वर्तमान कनेक्शन तर्क काम करेगा, यह केवल एक चेतावनी प्रिंट करेगा। इस बीच, कृपया बेझिझक एक अलग जीथब मुद्दे में आपके किसी भी मुद्दे की रिपोर्ट करें।

बस नया तरीका अपनाया और यह बहुत अच्छा काम करता है। सभी को धन्यवाद!

@ vkarpov15 स्पष्टीकरण के लिए धन्यवाद।

एफवाईआई के रूप में, वही बहिष्करण चेतावनी openSet के साथ भी फेंक दी जाती है (मैं एक प्रतिकृति सेट का उपयोग कर रहा हूं)।

तो संक्षेप में, इस चेतावनी को अभी के लिए अनदेखा करना सुरक्षित है क्योंकि यह केवल नेवला के आंतरिक कामकाज से संबंधित है, और हम useMongoClient का उपयोग करने का प्रयास कर सकते हैं लेकिन अभी तक ऐसा नहीं करना है।

आपके हिसाब से यह कितना स्थिर है? क्या यह उपयोग करने के लिए सुरक्षित है? मैं यह पता लगाने के लिए कि यह अभी भी उत्पादन में अनुपयोगी है, मैं अपने सभी मॉडलों और कनेक्शन तर्क को दोबारा करने में 2 घंटे खर्च नहीं करना चाहता हूं।

क्या ऐसे समय तक पदावनति चेतावनी को हटाना संभव है जब तक कि ध्वज का उपयोग स्थिर न हो और आगे बढ़ने के लिए कनेक्ट करने का अनुशंसित तरीका न हो? या वह बिंदु पहले ही पहुंच गया है?

@vkarpov15

लेकिन मैं createConnection पर async का उपयोग कर रहा हूं। मैंने डीबी सर्वर के खिलाफ दो परीक्षण स्थापित किए हैं। यूआरएल काम करता है यह सुनिश्चित करने के लिए पहला मूल मोंगो-जेएस कैनरी टेस्ट है और मैं लिख और पढ़ सकता हूं:

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

परिणाम:

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

नेवला परीक्षण द्वारा सफल नेवला निर्माण का उपयोग कर प्रतीक्षा के साथ कनेक्शन:

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

});

और यह निम्न त्रुटि फेंकता है:

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

मैं यहां बहुत गलत हो सकता हूं, लेकिन मेरे लिए यह एक एसिंक/वादा समस्या की तरह नहीं दिखता है;

मैं मोंगो एटलस का उपयोग कर रहा हूं। जब मैं {useMongoClient: true} का उपयोग करता हूं, तो मेरा ऐप सफलतापूर्वक डेटाबेस से कनेक्ट हो जाएगा लेकिन डेटाबेस एप्लिकेशन का जवाब नहीं देता है, वैसे?

मेरा कोड:
mongoose.connect(config.dbhost, {useMongoClient: true}, function(err){ if(err){ console.log(err); } else { console.log('connected to the database successfuly.'); } });

सभी के लिए बस एक नोटिस क्योंकि मैंने इसे यहां उल्लेखित नहीं देखा है: 4.11.1 जारी किया गया है और एक त्वरित रूप से देखने के बाद ऐसा लगता है कि useMongoClient=true का उपयोग करते समय बफरिंग समस्या ठीक हो गई है। मैं कल और परीक्षण करूंगा। किसी और को?

अंतिम समाधान क्या है?

इसने मेरे लिए काम किया (व.4.11.1):

डेटाबेस.जेएस

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

अपडेट करें

अपने मॉडल को प्रारंभ करते समय कनेक्शन को संदर्भित करना आवश्यक नहीं हो सकता है (धन्यवाद, @kyrylkov @peterpeterparker):

user.model.js

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

क्या कोई संक्षेप में बता सकता है कि वास्तव में {useMongoClient: true} क्या है या वह ध्वज क्या करता है?

मैं थोड़ा खो गया हूँ, इसका उपयोग करने का क्या फायदा है?

मेरा मतलब है, जैसा कि मैंने पहले कहा था, मैं चेतावनी के साथ जी सकता था इसलिए मुझे इस परम को जोड़ने की जल्दी नहीं है।
दस्तावेज़ में इतना कुछ नहीं मिला, इसे साफ़ करने के लिए अग्रिम रूप से thx।

@ ब्लैकबॉड-स्टीवब्रश यह काम नहीं करता है। मैं मोंगो एटलस का उपयोग कर रहा हूं। यह काम क्यों नहीं करता है?

@Thinkdiff

कैसे काम नहीं करता? यह हमारे लिए सामान्य रूप से mLab और MongoDB एटलस पर काम करता है:

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

के बजाय:

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

यदि मैं यूआरआई में परिभाषित कुछ मेजबानों के साथ उपयोगमोंगो क्लाइंट विकल्प को सक्षम करने का प्रयास करता हूं, तो यह लटकता है और फिर त्रुटि फेंकता है:
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'
यूरी: मोंगोडब: //10.0.1.49 , 10.0.2.158,10.0.3.84/pss
विकल्प: { useMongoClient: true, autoReconnect: true, KeepAlive: 300000, ConnectTimeoutMS: 30000}

रुचि रखने वाले किसी भी व्यक्ति के लिए, यहां useMongoClient पैरामीटर पर नेवला दस्तावेज़ हैं: http://mongoosejs.com/docs/connections.html#use -mongo-client

"मोंगोज़ का डिफ़ॉल्ट कनेक्शन तर्क 4.11.0 के रूप में बहिष्कृत है ... यह बहिष्करण इसलिए है क्योंकि मोंगोडीबी ड्राइवर ने एक एपीआई को बहिष्कृत कर दिया है जो मोंगोडीबी 3.6 का समर्थन करने के लिए नेवला के कनेक्शन तर्क के लिए महत्वपूर्ण है, अधिक जानकारी के लिए यह जीथब मुद्दा देखें।" यहाँ GitHub मुद्दा है: https://github.com/Automattic/mongoose/issues/5304

@ ब्लैकबॉड-स्टीवब्रश thx यह इंगित करने के लिए कि हमारी। तो अगर मैं सही ढंग से समझूं

useMongoClient = true => नया कनेक्शन तर्क सक्रिय करें जो Mongo 3.6 के साथ भी काम करेगा
useMongoClient = false => डिफ़ॉल्ट मान। पुराना कनेक्शन तर्क <4.11.0. वह जो पदावनत हो।

सही?

@ ब्लैकबॉड-स्टीवब्रश आपके कोड के टुकड़े के बारे में, मेरे मामले में मैं उपयोग नहीं करता

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

लेकिन

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

और यह अभी भी सफल रहा। धन्यवाद

नेवला मेरे लिए काम करता है 4.10.8:|

मैंने पाया है कि यह नेवले के साथ एक बग होने की संभावना है

नेवला संस्करण को वापस लाने के बाद समस्या दूर हो गई

npm अनइंस्टॉल - नेवला बचाओ
npm इंस्टाल-सेव नेवला@4.10.8

मैंने इस चेतावनी को पूरी तरह से नजरअंदाज कर दिया है और सब कुछ उम्मीद के मुताबिक काम कर रहा है। शायद, यह अभी के लिए समाधान है। बस नज़रअंदाज़ कर दो।

4.10.8 पर वापस आने से मेरा कनेक्शन फिर से काम कर रहा है, हालांकि मुझे अभी भी त्रुटि मिलती है

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

@peterpeterparker सही। मेरी समझ के आधार पर नेवला का वर्तमान प्रमाणन कोड मोंगोडब 3.6 पर काम नहीं करेगा, इसलिए useMongoClient हमें इस समस्या से आगे निकलने की कोशिश करने का प्रतिनिधित्व करता है जबकि पश्च संगतता बनाए रखता है। जहां तक ​​​​मुझे पता है कि मोंगोडब 3.6 के लिए अभी तक कोई निर्धारित रिलीज की तारीख नहीं है, इसलिए स्विच करना दबाव नहीं बना रहा है।

@adamreisnz हमारे पास कुछ बग हैं लेकिन वास्तव में नया कनेक्शन तर्क मूल ड्राइवर के MongoClient.connect() फ़ंक्शन का उपयोग करने के लिए एक बहुत ही पतला आवरण है, जो अब कुछ वर्षों से mongodb से कनेक्ट करने का पसंदीदा तरीका रहा है। एक बार जब आपका कनेक्शन स्थापित हो जाता है तो कनेक्शन को बनाए रखने वाला वही मोंगोडब ड्राइवर तर्क होता है। useMongoClient केवल प्रारंभिक कनेक्शन को प्रभावित करना चाहिए।

@ vkarpov15 स्पष्टीकरण के लिए और निश्चित रूप से काम के लिए बहुत कुछ, वास्तव में इसकी सराहना करते हैं!

@ vkarpov15 धन्यवाद, मैं इसे आज़मा दूंगा और useMongoClient का उपयोग करने के लिए स्विच करूंगा और देख सकता हूं कि यह हमें कहां ले जाता है।

कॉन्स्ट नेवला = आवश्यकता ("मोंगोज़");
कॉन्स्ट डीबी = " मोंगोडब: // लोकलहोस्ट / टेस्टारू ";

mongoose.connection.openUri(db);
mongoose.connection.once ("खुला", फ़ंक्शन () {
कंसोल.लॉग ("कनेक्शन स्थापित");
}).पर ("त्रुटि", फ़ंक्शन (त्रुटि) {
कंसोल.लॉग (त्रुटि);
})

--मैं इसका उपयोग करता हूं और कोई त्रुटि नहीं मिली

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;

मैं इसका उपयोग करता हूं और कोई त्रुटि नहीं मिली

@vitorbarros इसने मेरे लिए काम किया। धन्यवाद!

इससे मेरा काम बनता है:
http://mongoosejs.com/docs/connections.html#use-mongo-client

मैंने यह त्वरित परीक्षण चलाया और इसने काम किया:

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

तो 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)

आप सभी को धन्यवाद!

@vitorbarros आपका समाधान काम करता है! धन्यवाद।

मैं पुष्टि कर सकता हूं कि 4.11.3 के साथ कनेक्शन तर्क को बदलकर @vitorbarros ने जो सुझाव दिया है वह चेतावनियों को हटा देता है और अच्छी तरह से काम करता प्रतीत होता है

इस धागे में पहले सुझाए गए मॉडल संदर्भों को दोबारा करने की कोई आवश्यकता नहीं है।

@vitorbarros का समाधान वास्तव में " useMongoClient Option" दस्तावेज़ीकरण के अनुसार अनुशंसित तरीका है।

हालांकि, ध्यान दें कि mongoose.Promise = global.Promise; _not_ अंतर्निहित Mongo ड्राइवर का वादा करेगा । "मोंगोडीबी ड्राइवर के लिए वादे" दस्तावेज़ के अनुसार, promiseLibrary संपत्ति को connect विधि के विकल्प ऑब्जेक्ट में भी सेट किया जाना चाहिए।

उदाहरण के लिए:

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

global.Promise मूल वादा इंजन का उपयोग करेगा। स्वाभाविक रूप से, ब्लूबर्ड या किसी अन्य इंजन का उपयोग करना भी संभव है, जैसे promiseLibrary: require('bluebird')

@vitorbarros समाधान मेरे लिए काम करता है। और हमें @ बोअज़-अमित जैसे वादे लाइब्रेरी का उपयोग करने की भी आवश्यकता है।
लेकिन प्रमाणीकरण डेटा का उपयोग करने के लिए कौन सा तरीका सबसे अच्छा है?
यूआरएल में

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

या बेहतर विकल्प में उपयोगकर्ता और पासवर्ड सेट करें? मुझे अभी के लिए सही जगह नहीं मिल रही है।

प्रमाणित करने का यह केवल एक ही तरीका है?

और यहाँ मेरा समाधान है। यह तब भी काम करता है जब पहला कनेक्ट विफल हो जाता है।

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

इसे यूआरएल में होना चाहिए, उपयोगकर्ता/पास विकल्प अब काम नहीं करते हैं
useMongoClient सच मैंने पाया।

सोम, जुलाई 17, 2017, 20:28 को एंड्री प्रिस्नियाक नोटिफिकेशन @github.com
लिखा था:

@vitorbarros https://github.com/vitorbarros समाधान मेरे लिए काम करता है। और
इसके अलावा हमें @ boaz-amit . जैसे वादे पुस्तकालय का उपयोग करने की आवश्यकता है
https://github.com/boaz-amit ने कहा।
लेकिन प्रमाणीकरण डेटा का उपयोग करने के लिए कौन सा तरीका सबसे अच्छा है? यूआरएल में
मोंगोडब: // [ उपयोगकर्ता नाम: पासवर्ड @
]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
या बेहतर विकल्प में उपयोगकर्ता और पासवर्ड सेट करें? मुझे इसके लिए सही जगह नहीं मिल रही है
अभी।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Automattic/mongoose/issues/5399#issuecomment-315694642 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAd8Qup1YY4lhUhQccv2kLKtraARxvP0ks5sOxs_gaJpZM4OEnIt
.

@adamreisnz @aprisniak इस पर काम कर रहे हैं, #5419 देखें। इस बीच, कृपया अपने यूआरआई में उपयोगकर्ता नाम और पासवर्ड डालें: mongodb://user:pass<strong i="7">@hostname</strong>:port/db

साथ ही, मैंने इस विकल्प के बारे में एक ब्लॉग पोस्ट लिखा है और यह क्यों आवश्यक है: http://thecodebarbarian.com/mongoose-4.11-use-mongo-client.html

@ vkarpov15 मैं उपयोगकर्ता का उपयोग कर रहा हूं: यूआरआई में पास , लेकिन अभी भी चेतावनी है।

उन लोगों के लिए जो नेवले का उपयोग gridfs-stream के साथ करते हैं:

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

क्या आप लोग टाइपस्क्रिप्ट टाइपिंग में लापता कनेक्शन विकल्प "useMongoClient" जोड़ सकते हैं, और टाइपिंग पैकेज जोड़ने के बजाय इस प्रोजेक्ट में टाइपिंग वापस जोड़ सकते हैं।

मुझे यकीन नहीं है कि मुझे इस चेतावनी के साथ कुछ करना चाहिए या नहीं? यह ठीक हो जाएगा, है ना?

मैं इसे काम करने के लिए टाइपिंग में सिर्फ useMongoClient जोड़ता हूं। @iamdubx

@FinalDes कैसे? मैंने mongoose.connect(process.env.DATABASE, { useMongoClient: true }) जोड़ा लेकिन मुझे अभी भी संदेश मिला। और मैं उपयोगकर्ता का उपयोग कर रहा हूं: यूआरआई में पास करें

ऐसी समस्या से छुटकारा पाने का बेहतर तरीका इन दो आदेशों का उपयोग करना है:
npm अनइंस्टॉल - नेवला बचाओ
npm इंस्टाल-सेव नेवला@4.10.8

ध्यान दें: [email protected] स्थिर संस्करण है।

आप सभी अपनी स्कीमा और मॉडल बनाने के साथ-साथ उन तक पहुँचने का प्रबंधन कैसे कर रहे हैं?

मैंने धागे में हर फिक्स की कोशिश की है। चेतावनी के साथ, सब कुछ ठीक काम करता है। एक बार जब मैं useMongoClient: true या mongoose.createConnection की कोशिश करता हूं तो यह चेतावनी से छुटकारा पाता है और मैं डीबी से जुड़ सकता हूं, हालांकि मॉडल तक पहुंचने का प्रयास करने वाला कोई भी कोड ट्रिगर करने में विफल रहता है। कोई त्रुटि नहीं है, कोड बस कभी नहीं चलता है।

@iamdubx
बस टाइपिंग गायब है, इसलिए जब "noImplicitAny" के साथ चलाया जाता है: सत्य, त्रुटि नहीं होगी

आयात नेवला = आवश्यकता ("मोंगोज़");
आयात dotenv = आवश्यकता ("डॉटेनव");
dotenv.config ();
नेवला। वादा = वैश्विक। वादा;
const MONGO_URI=`mongodb://${process.env.MONGODB_HOST}:${process.env.MONGODB_PORT}/${process.env.MONGODB_DB}`;
mongoose.connect(MONGO_URI, {
मोंगो क्लाइंट का उपयोग करें: सच,
});

@FinalDes आप किसका जिक्र कर रहे हैं? क्या टाइपिंग गायब है? मेरे पास ऊपर एक ही कोड है और एक त्रुटि है।

मुझे @Snow-Okami . के साथ भी यही समस्या का सामना करना पड़ा है

1. const mongoDB = mongoose.connect(config.database, { useMongoClient: true });
   यह चेतावनी से छुटकारा पाता है और डीबी से जुड़ता है। हालांकि, मॉडल तक पहुंचने का प्रयास करने वाली हर चीज विफल हो जाती है (प्राप्त करें/पोस्ट करें)। कोई त्रुटि वापस नहीं आती है।
2. const mongoDB = mongoose.connect(config.database, function(){ useMongoClient: true });
   और यह उन दो चेतावनियों को देता है, लेकिन इसके अलावा सब कुछ ठीक काम करता है।

कृपया कम से कम पिछड़ा संगतता दें, हमारा उत्पादन निर्माण सर्वर विफल रहता है।
फीचर अपडेशन अच्छा है लेकिन मेथड सिग्नेचर या कॉल में बदलाव न करें।

@Nikunjkसंघवी यह केवल एक चेतावनी है, कुछ भी विफल नहीं होना चाहिए।

@iamdubx किस तरह की त्रुटि?

@FinalDes पदावनति त्रुटि, हम इस विषय में और किस बारे में बात कर रहे हैं?

इसने मेरे लिए काम किया: (व.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'})

// डीबी कनेक्शन
वर नेवला = आवश्यकता ('नेवला');
नेवला। वादा = वैश्विक। वादा;
mongoose.connect('mongodb://localhost/login_register', {
मोंगो क्लाइंट का उपयोग करें: सत्य
})
.then(() => कंसोल.लॉग('कनेक्शन सक्सेसफुल'))
कैच ((गलती) => कंसोल। त्रुटि (गलती));
// डीबी कनेक्शन अंत

यह मेरे काम नहीं आता। मेरे पास अभी भी कंसोल चेतावनी है। और कोई स्पष्ट स्पष्टीकरण प्रदान नहीं करता है।

नेवला भयानक है। इसके अलावा सबसे खराब प्रलेखन साइट जो मैंने पुस्तकालयों में देखी थी जो इतनी लोकप्रिय थी। कितनी शर्म की बात है!

अब मैं रेथिंकडीबी पर स्विच करने की सोच रहा हूं। लिनक्स फाउंडेशन - यह गंभीर है।
पोस्टग्रे भी कमाल है।

मोंगो - बहुत, बहुत शर्म की बात है।

@iamdubx क्या आपने ऊपर मेरे समाधान की कोशिश की? क्या आप इस पर चेतावनी चिपका सकते हैं? शायद मैं मदद कर सकता हूँ :)

@iamdubx आपका चेतावनी संदेश पोस्ट कर सकता है?

@ फ़ाइनलडेस @ शम्स-अली मैंने पहले पोस्ट किया था, यह वही पदावनति त्रुटि है जैसा विषय में है। यह विषय किस बारे में है!

(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 दिलचस्प है, यह वही चेतावनी है जो मेरे पास थी और उपरोक्त समाधान जो मैंने पोस्ट किया था, वह मेरे लिए इसे ठीक कर रहा था। क्या आप अपना अद्यतन कोड पेस्ट कर सकते हैं जो काम नहीं कर रहा है?

इसी से मेरा काम बना है:

// 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 काम करता है धन्यवाद

@FinalDes आपका स्वागत है दोस्त।

यह मेरा नया कार्यप्रवाह है, जो चेतावनियों और बहिष्करणों के अनुरूप होने का प्रयास कर रहा है:

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

और अब मॉडल मॉड्यूल कनेक्शन का एक फ़ंक्शन देता है

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


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

// Other Schemas
...

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

इस विषय पर कोई आधिकारिक दिशानिर्देश?

@iamdubx लगता है जैसे आप चेतावनी और त्रुटि के बीच अंतर को नहीं समझते हैं।

विचाराधीन चेतावनी कुछ भी नहीं तोड़ती है, लेकिन उपयोगकर्ता को किसी ऐसी चीज़ की चेतावनी देती है जिसे अगली बड़ी रिलीज़ में हटा दिया जाएगा।

नेवला भयानक है।

इसलिए ध्यान रखें, डेवलपर द्वारा किसी सुविधा को हटाने से पहले आपको चेतावनी देने के लिए आपको यह प्रतिक्रिया मिल रही है। मैं आपसे यह भी याद रखने का आग्रह करता हूं कि आप इसका नि: शुल्क उपयोग कर रहे हैं, इसलिए शायद डेवलपर्स को संदेह का लाभ दें इससे पहले कि आप एक तंत्र-मंत्र फेंक दें

@chrisdothtml

विचाराधीन चेतावनी कुछ भी नहीं तोड़ती है, लेकिन उपयोगकर्ता को किसी ऐसी चीज़ की चेतावनी देती है जिसे अगली बड़ी रिलीज़ में हटा दिया जाएगा।

यह प्रदूषण परीक्षण और कंसोल करता है जो हल्का परेशान है।

नेवला भयानक है। इसके अलावा सबसे खराब प्रलेखन साइट जो मैंने पुस्तकालयों में देखी थी जो इतनी लोकप्रिय थी। कितनी शर्म की बात है!

वह असभ्य हो रहा है जो थोड़ा परेशान करने वाला भी है लेकिन वह नेवला प्रलेखन के संबंध में एक बहुत ही मान्य बिंदु बनाता है। यह अब तक का सबसे खराब दस्तावेज नहीं है, लेकिन वास्तव में इसमें सुधार किया जा सकता है।

तथ्य यह है कि नेवला मोंगो क्लाइंट एपीआई को आगे बढ़ाता है। जो बहुत अलग तरीके से काम करता है, Mongoose के उपयोग और दस्तावेज़ीकरण को भ्रमित करता है।

इसके लिए एक संभावित समाधान होगा:

• इसे करना बंद करो
• Mongo क्लाइंट विधियों के लिए दस्तावेज़ीकरण निकालें
• आधिकारिक क्लाइंट और नेवला के बीच कनेक्शन साझा करने का एक तरीका प्रदान करें

मैं यह भी सुझाव दूंगा कि दस्तावेज़ों की खोज क्षमता को कई पृष्ठों में तोड़कर और नए उपयोगकर्ताओं को इस बारे में अधिक जानकारी दें कि कुछ परिणाम प्राप्त करने के लिए Mongoose वास्तव में क्या कर रहा है।

मेरे पास यह त्रुटि थी, लेकिन मेरे द्वारा {useMongoClient: true} विकल्प जोड़ने के बाद यह गायब हो गया।
मैं MongoDb ver के साथ डेबियन 9, परीक्षण संस्करण का उपयोग करता हूं। 3.2.11 और नेवला देखें। 4.10.4.
मेरे पास 'मोंगोडीबी से कनेक्टेड' संदेश है (नीचे टाइपस्क्रिप्ट में कोड देखें), सब कुछ पूरी तरह से काम करता है।

(<कोई भी> नेवला)। वादा = वैश्विक। वादा;
mongoose.connect(process.env.MONGODB_URI, {useMongoClient: true});
कास्ट डीबी = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
एक बार ('खुला', () => {
कंसोल.लॉग ('मोंगोडीबी से जुड़ा');
सेटरूट्स (ऐप);
app.get('/*', function(req, res) {
res.sendFile(path.join(__dirname, '../public/index.html'));
});
app.listen(app.get('port'), () => {
कंसोल.लॉग ('MyApp पोर्ट पर सुन रहा है' + ऐप.गेट ('पोर्ट'));
});
});

बस मौजूदा नेवला संस्करण को अनइंस्टॉल करें जो आपके पास है और निचला संस्करण npm install [email protected] --save स्थापित करें। कुछ और करने की जरूरत नहीं है यह निश्चित रूप से आपके काम आएगा।

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

इससे मेरी समस्या हल हो गई। लेकिन मेरे द्वारा यह परिवर्तन करने के बाद मेरे पास एक और चेतावनी आ रही थी।

पदावनति चेतावनी: नेवला: mpromise (नेवला का डिफ़ॉल्ट वादा पुस्तकालय) पदावनत है, इसके बजाय अपने स्वयं के वादे पुस्तकालय में प्लग इन करें: http://mongoosejs.com/docs/promises.html

यह कोड सभी बहिष्करण चेतावनियों को हल करता है:
```जावास्क्रिप्ट
नेवला। वादा = वैश्विक। वादा;
mongoose.connect (यूरी, {
जिंदा रखना: सच,
पुन: कनेक्ट करने का प्रयास: Number.MAX_VALUE,
मोंगो क्लाइंट का उपयोग करें: सत्य
});
````
लिंक द्वारा अधिक जानकारी -> http://mongoosejs.com/docs/connections.html#use -mongo-client

@ब्रिक्स शानदार! धन्यवाद!

@bricss आपने मेरा दिन बना दिया।

किसी ने हीरो बैज अर्जित किया ...

संपादित करें: @bricss इसने मेरे लिए बहिष्करण चेतावनियों को समाप्त कर दिया, लेकिन मैं अपने mLab सैंडबॉक्स से डेटा पुनर्प्राप्त नहीं कर सका। ऐसा इसलिए हो सकता है क्योंकि वे MongoDB के पुराने संस्करण का उपयोग कर रहे हैं। मैं बाद में इसकी जांच करने की कोशिश करूंगा।

संपादित करें: @bricss अब यह नवीनतम नेवला 4.11.9 और Azure पर Cosmos DB से कनेक्शन के साथ सही ढंग से काम कर रहा है।

@bricss : अच्छी तरह से की गई ईंटें! यह मेरे लिए काम करता है, भले ही मैं अपने स्थानीय में मोंगोडब के पुराने संस्करण का उपयोग कर रहा हूं: +1:

@ब्रिक्स अवेसो ! लेकिन आप "reconnectTries" के लिए एक छोटी संख्या डालने पर विचार कर सकते हैं। यदि आपके डीबी के साथ कोई समस्या है तो आप पूरे दिन फिर से कनेक्ट नहीं करना चाहते हैं।

@afoke के समाधान ने मेरे लिए काम किया, केवल तभी जब मैं कनेक्शन स्ट्रिंग यानी mongodb://localhost:27017/test में स्पष्ट रूप से डीबी घोषित करता हूं लेकिन mongodb://localhost:27017 नहीं

क्या मैं इस चेतावनी के बिना 2 DB का कनेक्शन बना सकता हूँ? मुझे विभिन्न डीबी के साथ अपने मॉडल का उपयोग करने की ज़रूरत है।

नेवला v^4.11.6 का उपयोग करते हुए, जब useMongoClient जोड़ा गया तो चेतावनी गायब हो गई।

const uri = "http://blablabla.blo/blaDB"; mongoose.Promise = global.Promise; mongoose.connection.on('error', (err) => { console.error( नेवला कनेक्शन त्रुटि: ${err}`);
प्रक्रिया.बाहर निकलें(1);
});
mongoose.connect(uri, {useMongoClient: true});

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

इस तरह डेटाबेस से जुड़ने से समस्या हल हो जाती है:
mongoose.connect(url,{user:'username',pass:'mypassword',useMongoClient:true});

क्या ये त्रुटियां समस्याएं पैदा करेंगी, उदाहरण के लिए सुरक्षा में?

यदि मैं इस सिंटैक्स का उपयोग करता हूं तो कोई और "बहिष्कृत" चेतावनी पॉप अप नहीं होती है

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

मुझे नीचे के समान ही बहिष्करण चेतावनी का सामना करना पड़ा:
(नोड: 2300) पदावनति चेतावनी: open() नेवला में पदावनत है >= 4.11.0, इसके बजाय openUri() का उपयोग करें, या connect() का उपयोग करने पर useMongoClient विकल्प सेट करें या createConnection() । देखें http://mongoosejs.com/docs/connections.html#use -mongo-client

समाधान

मैंने निम्नलिखित की कोशिश की और यह ठीक काम करता है। कोई बहिष्करण चेतावनी नहीं देता है।

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

उम्मीद है कि इससे इस मुद्दे का सामना करने वाले सभी लोगों को मदद मिलेगी।

मेरे पास एक ही समस्या है लेकिन मोंगो एटलस सेवा से कनेक्ट करने का प्रयास करते समय यह सिर्फ {useMo ngoClient: true } विकल्प से कनेक्ट नहीं होता है और इसके बिना कनेक्शन अब निष्पादित नहीं होता है।

कोई भी एक ही मुद्दे के साथ?

मैंने अपनी समस्या का समाधान सिर्फ mongoose.connect को mongoose.createConnection में बदलकर किया था

mongoose.createConnection (config.uri, (गलती) => {
अगर (गलती) {
कंसोल.लॉग ('डेटाबेस से कनेक्ट नहीं हो सका:', इरेट);
} अन्य {
कंसोल.लॉग ('डेटाबेस से कनेक्टेड:' + config.db);
}
});

मैंने इस समस्या को इस तरह हल किया (मोंगोज़ 4.12.0, नोडजेएस - 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);
});