Mongoose: DeprecationWarning: `open()` está en desuso en mongoose >= 4.11.0, use `openUri()` en su lugar

+1, no tengo idea de dónde arreglar para deshacerme de esa advertencia

La advertencia es para un código dentro de Mongoose en realidad, cuando la cadena de conexión tiene un conjunto de réplicas:

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

Entonces, ¿esto es un error?

parece un error, ¿podemos solucionarlo agregando useMongoClient: true a las opciones (es posible que vea una desaprobación del controlador MongoDB, pero eso no arroja)

Agregar useMongoClient: true hace que el mensaje desaparezca, pero mis documentos simplemente dejan de cargarse. No lo he depurado más profundamente, pero preferiría escuchar las mejores prácticas primero antes de adaptar mi código.

Mi aplicación tampoco funciona con la solución sugerida anteriormente. Simplemente ya no ejecuta el método MyModel.find y no da error ni tiempo de espera.

La razón por la cual la opción "useMongoclient: true" no funciona en la mayoría de los casos es que para esa opción, cada objeto relacionado con la conexión de mongoose devuelve un objeto ficticio porque no puede acceder a mongodb

Traté de usarlo como

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

pero no funciona

Tener el mismo problema, incluso sin conjuntos de réplicas.

Tener el mismo problema:

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

Mismo...

Después de agregar el siguiente código a mi conexión mongo, no puedo consultar nada ahora.
{usarMongoClient: verdadero}.
Cualquier sugerencia será apreciada!!

+1 lo mismo con conjuntos de réplicas, sin fragmentación

+1

+1

+1

+1

+1

+1

+1

La solución más fácil para esto; " npm remove mongoose " luego " npm install [email protected] --save " problema resuelto. Actualizar no siempre es la mejor opción.

+1

+1

me salen 2 mensajes:

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

El primer error apareció en 4.11.0. El segundo error también apareció en la versión anterior de Mongoose.

plhosk, el segundo debería haberse arreglado en 4.11 pero parece que todavía está allí, para mí también.

+1

+1 por desgracia.

Instalado 4.10.8 sin problemas. Considere cambiar npm install mongoose --save por defecto a 4.10.8 hasta que 11 sea estable.

+1

+1

+1

+1

También encontré este problema.
__Versión del nodo__: v6.10.0

__MongoDB__ emvironment: (Corrí en la última versión del contenedor acoplable Mongo)

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

Mi configuración de conexión:

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

Cuando uso useMongoClient para ser falso. Mongoose muestra las siguientes advertencias:

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

Pero funciona bien.

Sin embargo, cuando lo configuré en true , encontré este error:

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)

También intento eliminar authSource=admin de la URL de conexión, pero sigue sin funcionar

(nodo: 451) Advertencia de desuso: open() está en desuso en mongoose >= 4.11.0, use
openUri() en su lugar, o establezca la opción useMongoClient si usa connect() o createConnection()
El método Db.prototype.authenticate ya no estará disponible en el próximo gran re
arrendamiento 3.x ya que MongoDB 3.6 solo permitirá la autenticación contra usuarios en la base de datos de administración y w
Ya no permitiré múltiples credenciales en un socket. Por favor autentícate usando M
ongoClient.connect con credenciales de autenticación.

Me sale este problema con mongoose versión 4.11.0 y MongoDB versión 3.4.5

+1

+1

Utilizar

mongoose.createConnection(URI)

@nandofalcao Al usar:

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

Aparentemente no puedo guardar nuevos registros.

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

Agregando políglota esta noche y +1 experimentando esto.

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

y me sale el segundo mensaje:

[2017-06-27 16:14:23.702] [INFO] :: - El servidor se inició en el puerto 2000

(nodo: 1193) Advertencia de desuso: open() está en desuso en mongoose >= 4.11.0, use openUri() en su lugar, o configure la opción useMongoClient si usa connect() o createConnection()

El método Db.prototype.authenticate ya no estará disponible en la próxima versión principal 3.x, ya que MongoDB 3.6 solo permitirá la autenticación contra usuarios en la base de datos de administración y ya no permitirá múltiples credenciales en un socket. Autentíquese usando MongoClient.connect con credenciales de autenticación.

+1

+1

+1

+1

+1

¿Alguien puede bloquear esto para evitar +1 inútiles?

Como cortesía a los suscriptores de este hilo, deje de responder con +1 porque genera notificaciones de correo electrónico inútiles. Esto no es un foro. Si desea seguir este hilo, use el botón de suscripción en la barra lateral derecha. También podrías investigar un poco tú mismo y aportar soluciones.

Cambié la versión a 4.10.8 y ahora funciona bien.

Parece que ValYouW tiene una solución potencial para el problema de carga de documentos aquí: #5404

mangosta.conexión.openUri('mongodb://127.0.0.1/camp_v12')

¿Alguien ha probado esto? mi advertencia obsoleta desapareció cuando uso esto, era de la documentación

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

@crisamdegracia eso supone que ya tienes conexión

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

lo cual no hacemos (al menos yo, ya que solía conectarme a mongodb usando el método mongoose.connect)

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

No pude encontrar ningún documento... ¿Qué pasa?

+1

Entonces, después de mirar el problema vinculado de @ phased90 que explica que puede conectarse así:

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

Revisé rápidamente el código y parece que 4.11 devuelve MongooseThenable excepto cuando se proporciona la opción {useMongoClient: true} . En ese caso, llama a Connection.prototype.openUri que devuelve una nueva instancia de Promise.ES6 . ¿Debería esa llamada Connection.prototype.openUri envolverse en un MongooseThenable ?

Mis disculpas por la pregunta, esta es la primera vez que miro este código base, así que no estoy seguro. Pero me complacería intentar ayudar a proporcionar una solución si puedo obtener alguna aclaración sobre si Moongoose.prototype.connect siempre debe devolver una instancia de MongooseThenable .

Tenga en cuenta que el uso {useMongoClient: true} hará que se llame a Connection.prototype.openUri , lo que no activará los comandos almacenados en búfer que se crearon __antes__ de conectarse a una base de datos debido a #5404

+1

Lo siento, las cosas han estado locas, echaré un vistazo en un momento.

@varunjayaraman no hay necesidad de disculparse amigo. Las personas pueden esperar o intentar arreglarlo por sí mismas.

+1

Entonces, con respecto al problema real que se abrió, la advertencia de desaprobación no es un error, es solo una advertencia: mongoose dejará de usar su lógica de conexión actual, por lo que debe pasar el useMongoClient . Esto se puede encontrar en la documentación.

En una nota separada, parece que esto fue un cambio radical hacia atrás, con suerte esto se puede arreglar en la próxima versión menor (o tal vez no lo sea, estoy durmiendo muy poco aquí):

esto normalmente funcionaría (salvo por la parte useMongoClient , que es nueva):

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

Esto parece arrojar un error para mí porque db.model ya no es una función.

Cuando se usa mongoose.model , funciona:

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 Acabo de actualizar Mongoose y uso useMongoClient: true como sugieres, pero tengo un problema.
No admite, de acuerdo con la documentación oficial de Mongoose , las opciones user y pass :

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

Y, sí, no se pudo autenticar. :-1:

Intentaré agregar un usuario y pasar la cadena de conexión en su lugar.
Funciona cuando agrego el nombre de usuario y la contraseña en la cadena de conexión. Tal vez deberías actualizar la documentación. 😐

@itpcc intentar usar la versión 4.10.8 es la mejor solución en este momento.

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

Crédito: @Chenz62

@CQBinh Gracias por tu consejo. Ya leí esos comentarios al respecto.
Sin embargo, no creo que usar la versión anterior sea la mejor solución por ahora. Y puede resolverse insertándolo en una cadena de conexión.
Me siento confundido porque se mencionó en el documento pero no funciona. :/
Por cierto, informo como un nuevo problema aquí

@varunjayaraman si db.model ya no está presente, ¿cómo se manejarían varias conexiones de mangosta diferentes con diferentes modelos?

por ejemplo, model1 y model2 adjuntos a mongooseConnection1 y model3 y model4 adjuntos a mongooseConnection2.

Anteriormente, esto se hacía llamando a mongoose.createConnection para cada una de las conexiones y adjuntando los modelos a cada uno de estos valores devueltos.

Editar: ¿O sigue funcionando en este caso?

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

+1

@boyce-ywr EN SERIO, otro +1??? Que les pasa gente??
Publica comentarios constructivos, no cosas así.

Con respecto a la mangosta, no me queda claro si el método mongoose.connect() se reemplazará en versiones futuras o no. Alguien podría explicar por favor?

@simonemazzoni Tienes razón, nos están enviando SPAM.

Si desea ser incluido en las notificaciones de este hilo, todo lo que necesita hacer es suscribirse (hay un botón en la parte superior del hilo),

Todo lo que haces cuando haces +1 es enviar a todos aquí un correo electrónico que diga

¡Hola estoy aqui!

No nos importa , estamos esperando comentarios constructivos y una solución .

Además, ¿por qué todos los +1 no eliminan sus publicaciones de esta lista? Son una monstruosidad y un dolor en la parte trasera tener que desplazarse para llegar a los comentarios reales.

Como algunas personas dijeron antes, la única "solución" es volver a [email protected]_ ...
¡Por ahora!

Parece un error, volví a [email protected] para resolver el problema

Use mongoose.createConnection(...) en lugar de mongoose.connect(...)

Aquí hay un ejemplo de trabajo completo del uso de [email protected] basado en la recomendación de @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 Entonces, ¿simplemente soltamos connect y usamos createConnection en su lugar?

@bertolo1988 al igual que la gente sugirió sobre este problema, actualmente hay dos soluciones alternativas

1. Regresar a 4.10.8
2. Use el nuevo patrón si desea seguir con la nueva versión

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

Yo personalmente prefiero la segunda solución.

¡¡¡Gracias!!!
resuelto por createConnection, y use esa conexión para hacer un modelo (en lugar de mangosta)

let mongoose = require('mongoose');

mongoose.Promise = global.Promise;

module.exports = mongoose;

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

El nuevo patrón de conexión requiere algunos cambios en el código y, según el tamaño de su proyecto, eso puede significar mucho tiempo e incluso cambios en la arquitectura (dado que la creación de un modelo requiere una conexión).

Hubiera sido genial si el antiguo modelo de conexión pudiera envolver el nuevo modelo de conexión.

Hay muchas publicaciones, así que puedo tratar de resumir:

1. La advertencia es una advertencia obsoleta, lo que significa que no hay prisa. Si no cambiamos nada, seguirá funcionando como siempre, todo parece estar bien.

2. De acuerdo con la advertencia, connect() será/ha sido modificado y será obligatorio pasar useMongoClient. Pero aquí está el posible error/problema

• connect('myurl', {useMongoClient: true}) => el documento deja de cargarse y no es posible escribir en la base de datos

• connect('myurl', {useMongoClient: false}) => parece funcionar bien, pero aún se muestra la advertencia

Por lo tanto, el propósito de este problema es corregir el uso de useMongoClient en el caso de la llamada del método connect.

¿Estar de acuerdo?

Aún así, si bien una advertencia de obsolescencia es de hecho "solo" una advertencia, que aparezca me hace preguntarme cuándo se eliminará realmente. Si mongoose está siguiendo a semver, aún debería estar allí en la rama 4.x. Por lo tanto, aún debería funcionar con compatibilidad con versiones anteriores hasta que se lance 5.x.

Con respecto al cambio en sí, es un poco molesto que no pude encontrar rápidamente nada relacionado con este cambio, excepto el mencionado en el registro de cambios. E incluso cuando lo cambia, las cosas aún se rompen y, según varias personas aquí, se debe a la llamada .model() .

Además, incluso los documentos aún muestran mongoose.connect() y mongoose.model() , lo que hace que este asunto sea aún más confuso. El cambio mongoose.connect() solo se menciona en Grupos de conexiones y no en otras partes de esta página . Entonces, la pregunta sigue siendo, ¿este cambio es un error o es intencionado?

No sé a dónde va esto, pero pasé la mayor parte de este fin de semana tratando de obtener una conexión con el Atlas de MongoDB. El controlador mongodb nativo se puso en marcha al instante y ejecutó las cosas CRUD.

Sin embargo, tratar de poner en marcha la mangosta es una pesadilla total. Si uso createConnection con 4.11, las conexiones del clúster se eliminan:

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

Alternativamente, podría configurar

useMongoClient: true

pero luego me quedo indefinido en la conexión.modelo

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

@Archomeda no tiene planes de eliminar el comportamiento de conexión heredado en 4.x, y 5.x está bloqueado para que la nueva lógica de conexión alcance un estado estable. Hay documentos sobre los documentos de conexión que 4.11.1 mejorarán y el enlace a eso debería ser útil. Re: la llamada model() , si especifica useMongoClient: true , createConnection() no devolverá una conexión, sino una promesa que se resuelve en una conexión que necesita para .then() activado. La justificación se describe aquí: https://github.com/Automattic/mongoose/issues/5404#issuecomment -312522539 No dude en expresar cualquier inquietud al respecto en el número 5404.

@mkastner parece que estás usando createConnection() . Con useMongoClient: true , createConnection() devuelve una promesa que se resuelve en una conexión. Utilice await mongoose.createConnection() o mongoose.createConnection().then()

@peterpeterparker #5404 señaló un problema con la nueva lógica de conexión que se corregirá en 4.11.1 y se lanzará en las próximas 24 horas.

@ cosminn777 , ¿qué problemas arquitectónicos tiene? Por favor abra un tema separado para discutirlos. El plan a largo plazo es que en 5.x no admitiremos Node < 4, por lo que todos los que usen mongoose tendrán acceso nativo a generadores y/o async/await, por lo que este cambio sería tan fácil como agregar yield o await estado de cuenta.

@alanpurple el problema al que te refieres es el mismo que el mencionado #5404 y se solucionará con 4.11.1.

@itpcc Abrí un problema separado para rastrear #5432. Por ahora, ingrese su nombre de usuario/contraseña en la URI: var dbURL = mongodb://${dbUser}:${dbPass}@${dbHost}:${dbPort}/${dbName}?authSource= administrador`.

En general, gracias a todos por su paciencia al probar este nuevo comportamiento. Me doy cuenta de que el cambio causará algunos dolores de cabeza, razón por la cual ocultamos este comportamiento detrás de una bandera, pero algunos cambios que se avecinan para MongoDB 3.6 requieren una revisión completa de la lógica de conexión interna de mongoose. Espero que la nueva lógica de conexión genere menos errores de conexión específicos de mangosta a largo plazo, pero tenga paciencia con nosotros mientras solucionamos el comportamiento y la documentación. Su opinión es muy apreciada.

Mientras esté en 4.x, su lógica de conexión actual funcionará, solo imprimirá una advertencia. Mientras tanto, siéntase libre de informar cualquier problema que tenga en un problema separado de github.

Acabo de adoptar el nuevo método y funciona muy bien. ¡Gracias a todos!

@ vkarpov15 gracias por las aclaraciones.

Como FYI, también se lanza la misma advertencia de obsolescencia con openSet (estoy usando un conjunto de réplicas).

Entonces, para resumir, es seguro ignorar esta advertencia por ahora, ya que solo se relaciona con el funcionamiento interno de Mongoose, y podríamos intentar usar useMongoClient pero aún no es necesario.

¿Qué tan estable es, crees? ¿Es seguro de usar? No me gustaría pasar 2 horas refactorizando todos nuestros modelos y la lógica de conexión para descubrir que aún no se puede usar en producción.

¿Es posible quizás eliminar la advertencia de desaprobación hasta el momento en que el uso de la bandera sea estable y la forma recomendada de conectarse en el futuro? ¿O ya se ha llegado a ese punto?

@vkarpov15

Pero estoy usando async en createConnection. He configurado dos pruebas contra el servidor db. La primera es la prueba Canary nativa de mongo-js para asegurarme de que la URL funcione y pueda escribir y leer:

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

Resultado:

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

Sucedido por la prueba de mongoose usando mongoose createConnection con 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);
  }

});

Y arroja el siguiente error:

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

Podría estar terriblemente equivocado aquí, pero para mí no parece un problema asíncrono/promiso;

Estoy usando Mongo Atlas. Cuando uso {useMongoClient: true}, Mi aplicación se conectará a la base de datos con éxito, pero la base de datos no responde a la aplicación, ¿verdad?

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

Solo un aviso para todos porque no lo he visto mencionado aquí: se lanzó 4.11.1 y, después de un vistazo rápido, parece que se solucionó el problema del almacenamiento en búfer al usar useMongoClient=true. Probaré más mañana. ¿Alguien mas?

¿Cuál es la solución final?

Esto funcionó para mí (v.4.11.1):

base de datos.js

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

usuario.modelo.js

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

ACTUALIZAR

Es posible que no sea necesario hacer referencia a la conexión al inicializar su modelo (gracias, @kyrylkov @peterpeterparker):

usuario.modelo.js

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

¿Alguien podría explicar brevemente para qué sirve exactamente { useMongoClient: true } o qué hace esa bandera?

Estoy un poco perdido, ¿cuál es la ventaja de usarlo?

Quiero decir, como dije antes, podría vivir con la advertencia, por lo tanto, no tengo prisa por agregar este parámetro.
No encontré mucho en el documento, gracias de antemano por aclarar eso.

@ Blackbaud-SteveBrush No funciona. Estoy usando Mongo Atlas. ¿Por qué no funciona?

@pensar

no funciona como? Nos funciona en mLab y MongoDB Atlas con lo habitual:

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

en lugar de:

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

Si trato de habilitar la opción useMongoClient con algunos hosts definidos en el URI, se cuelga y luego arroja un error:
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
opciones: { useMongoClient: true, autoReconnect: true, keepAlive: 300000, connectTimeoutMS: 30000 }

Para cualquier persona interesada, aquí están los documentos de Mongoose sobre el parámetro useMongoClient : http://mongoosejs.com/docs/connections.html#use -mongo-client

"La lógica de conexión predeterminada de Mongoose está obsoleta a partir de 4.11.0... Esta obsolescencia se debe a que el controlador MongoDB ha obsoleto una API que es crítica para la lógica de conexión de mongoose para admitir MongoDB 3.6, consulte este problema de github para obtener más detalles". Aquí está el problema de GitHub: https://github.com/Automattic/mongoose/issues/5304

@Blackbaud-SteveBrush gracias por señalar que nuestro. Entonces si entiendo bien

useMongoClient = true => active la nueva lógica de conexión que también funcionará con Mongo 3.6
useMongoClient = false => valor predeterminado. lógica de conexión antigua < 4.11.0. el que está en desuso.

¿Correcto?

@Blackbaud-SteveBrush sobre su código, en mi caso no uso

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

pero

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

y aun así tuvo éxito. gracias

Mangosta me funciona 4.10.8 :|

Descubrí que es probable que se trate de un error con la mangosta

el problema desapareció después de revertir la versión de mongoose

npm desinstalar -guardar mangosta
npm install -save [email protected]

He ignorado por completo esta advertencia y todo funciona como se esperaba. Quizás, esta sea la solución por ahora. Solo ignoralo.

retroceder a 4.10.8 hizo que mi conexión funcionara de nuevo, sin embargo, sigo recibiendo el error

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

@peterpeterparker correcto. El código de autenticación actual de Mongoose no funcionará en mongodb 3.6 según tengo entendido, por lo que useMongoClient nos representa tratando de adelantarnos a este problema mientras mantenemos la compatibilidad con versiones anteriores. Hasta donde sé, todavía no hay una fecha de lanzamiento programada para mongodb 3.6, por lo que cambiar no es urgente.

@adamreisnz hemos tenido algunos errores, pero en realidad la nueva lógica de conexión es una envoltura muy delgada que utiliza la función MongoClient.connect() del controlador nativo, que ha sido el método preferido para conectarse a mongodb durante un par de años. Una vez que se establece su conexión, es la misma lógica del controlador mongodb que mantiene la conexión. useMongoClient solo debería afectar la conexión inicial.

@vkarpov15 muchas gracias por la explicación y, por supuesto, por el trabajo, ¡realmente lo aprecio!

@ vkarpov15 gracias, lo intentaré y cambiaré a useMongoClient y veré adónde nos lleva.

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

mangosta.conexión.openUri(db);
mangosta.conexión.once("abrir", función () {
console.log("conexión establecida");
}).on("error", función (error) {
consola.log(error);
})

--yo uso esto y no se encontraron errores

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;

Yo uso esto y no se encontraron errores.

@vitorbarros Me funcionó. ¡Gracias!

Esto funciona para mi:
http://mongoosejs.com/docs/connections.html#use-mongo-client

Hice esta prueba rápida y funcionó:

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

entonces node index.js me da:

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)

¡Gracias a todos!

@vitorbarros tu solución funciona! Gracias.

Puedo confirmar que con 4.11.3 reemplazando la lógica de conexión con lo que sugirió @vitorbarros elimina las advertencias y parece funcionar bien 👍

No hay necesidad de refactorizar las referencias del modelo como se sugirió anteriormente aquí en este hilo.

La solución de @vitorbarros es, de hecho, la forma recomendada de acuerdo con la documentación de "La opción useMongoClient " .

Sin embargo, tenga en cuenta que mongoose.Promise = global.Promise; _no_ prometerá el controlador Mongo subyacente . De acuerdo con la documentación de "Promises for the MongoDB Driver" , la propiedad promiseLibrary también debe establecerse en el objeto de opciones del método connect .

Por ejemplo:

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

global.Promise usaría el motor de promesa nativo. Naturalmente, también es posible usar Bluebird o cualquier otro motor, por ejemplo, promiseLibrary: require('bluebird')

La solución de @vitorbarros me funciona. Y también necesitamos usar promiseLibrary como dijo @boaz-amit.
Pero, ¿cuál es la mejor manera de usar los datos de autenticación?
En URL

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

o mejor establecer usuario y contraseña en opciones? No puedo encontrar el lugar correcto por ahora.

¿ Esta es solo una forma de autenticación?

Y aquí está mi solución. Esto también funciona incluso si falla la primera conexión.

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

Tiene que estar en url, las opciones de usuario/pase ya no funcionan con
useMongoClient verdadero que encontré.

El lunes 17 de julio de 2017 a las 20:28 Andrey Prisniak [email protected]
escribió:

@vitorbarros https://github.com/vitorbarros solución funciona para mí. Y
también necesitamos usar promiseLibrary como @boaz-amit
https://github.com/boaz-amit dijo.
Pero, ¿cuál es la mejor manera de usar los datos de autenticación? En URL
mongodb://[ nombre de usuario:contraseña@
]host1[:puerto1][,host2[:puerto2],...[,hostN[:puertoN]]][/[base de datos][?opciones]]
o mejor establecer usuario y contraseña en opciones? No puedo encontrar el lugar adecuado para
ahora.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/Automattic/mongoose/issues/5399#issuecomment-315694642 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/AAd8Qup1YY4lhUhQccv2kLKtraARxvP0ks5sOxs_gaJpZM4OEnIt
.

@adamreisnz @aprisniak trabajando en ello, ver #5419. Mientras tanto, ingrese el nombre de usuario y la contraseña en su URI: mongodb://user:pass<strong i="7">@hostname</strong>:port/db

Además, escribí una publicación de blog sobre esta opción y por qué es necesaria: http://thecodebarbarian.com/mongoose-4.11-use-mongo-client.html

@vkarpov15 Estoy usando user:pass en URI, pero aún tengo la advertencia.

Para aquellos que usan mongoose con 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 */
})

¿Pueden agregar la opción de conexión faltante "useMongoClient" en las escrituras mecanografiadas", y agregar escrituras nuevamente a este proyecto en lugar de agregar paquetes de escritura.

No estoy seguro de si debo hacer algo con esta advertencia o no. Se arreglará, ¿verdad?

Solo agrego useMongoClient en las escrituras para que funcione. @iamdubx

@FinalDes ¿Cómo? Agregué mongoose.connect(process.env.DATABASE, { useMongoClient: true }) pero aún recibí el mensaje. Y estoy usando usuario: pase en URI

La mejor manera de deshacerse de este problema es usar estos dos comandos:
npm desinstalar -guardar mangosta
npm install -save [email protected]

NB: [email protected] es la versión estable.

¿Cómo están manejando la creación de su esquema y modelo, así como el acceso a ellos?

He probado todas las soluciones del hilo. Con la advertencia, todo funciona bien. Una vez que pruebo useMongoClient: true o mongoose.createConnection , se deshace de la advertencia y puedo conectarme a la base de datos; sin embargo, cualquier código que intente acceder al modelo no se activa. No hay errores, el código nunca se ejecuta.

@iamdubx
solo faltan los tipos, por lo que cuando se ejecuta con "noImplicitAny": true, no tendrá error

importar mangosta = require("mangosta");
importar dotenv = require("dotenv");
dotenv.config();
mangosta.Promesa = global.Promesa;
const MONGO_URI=`mongodb://${proceso.env.MONGODB_HOST}:${proceso.env.MONGODB_PORT}/${proceso.env.MONGODB_DB}`;
mangosta.conectar(MONGO_URI, {
useMongoClient: verdadero,
});

@FinalDes a que te refieres? ¿Qué tipeos faltantes? Tengo el mismo código anterior y tengo un error.

He encontrado el mismo problema con @Snow-Okami

1. const mongoDB = mongoose.connect(config.database, { useMongoClient: true });
   Esto elimina la advertencia y se conecta a la base de datos. Sin embargo, todo lo que intenta acceder al modelo falla (get/post). No se devuelve ningún error.
2. const mongoDB = mongoose.connect(config.database, function(){ useMongoClient: true });
   Y esto da esas dos advertencias, pero todo lo demás funciona bien.

Por favor, al menos proporcione compatibilidad con versiones anteriores, nuestro servidor de compilación de producción falla.
la actualización de funciones es buena, pero no cambie la firma o la llamada del método.

@Nikunjksanghavi Es solo una advertencia, nada debería fallar.

@iamdubx ¿qué tipo de error?

Error de obsolescencia de @FinalDes , ¿de qué más estamos hablando en este tema?

Esto funcionó para mí: (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'})

// conexión a la base de datos
var mangosta = require('mangosta');
mangosta.Promesa = global.Promesa;
mongoose.connect('mongodb://localhost/login_register', {
useMongoClient: verdadero
})
.then(() => console.log('conexión exitosa'))
.catch((err) => consola.error(err));
// Fin de la conexión a la base de datos

Esto no funciona para mí. Todavía tengo la advertencia de la consola. Y no proporciona una explicación clara.

La mangosta es horrible. También el peor sitio de documentación que vi en bibliotecas tan populares. ¡Qué lástima!

Ahora estoy pensando en cambiar a RethinkDB. Fundación Linux: esto es serio.
También Postgre impresionante.

Mongo - muy, muy vergüenza.

@iamdubx , ¿probaste mi solución anterior? ¿Podrías pegar la advertencia en esto? Tal vez podría ayudar :)

@iamdubx puede publicar su mensaje de advertencia?

@FinalDes @shams-ali que publiqué antes, es el mismo error de desaprobación que tiene el tema. ¡De la que trata este tema!

(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 interesante, esa es la misma advertencia que tuve y la solución anterior que publiqué pareció solucionarlo. ¿Podrías pegar tu código actualizado que no funciona?

Esto es lo que funcionó para mí:

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

@FinalDes De nada compañero.

Este es mi nuevo flujo de trabajo, tratando de cumplir con las advertencias y obsolescencias:

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

Y ahora el módulo de modelos devuelve una función de conexión.

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


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

// Other Schemas
...

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

¿Alguna guía oficial sobre el tema?

@iamdubx Parece que no entiende la diferencia entre una advertencia y un error .

La advertencia en cuestión no rompe nada, pero advierte al usuario de algo que se eliminará en la próxima versión principal.

La mangosta es horrible.

Así que tenga en cuenta que está teniendo esta reacción cuando los desarrolladores le advierten con anticipación antes de eliminar una función. También le insto a que recuerde que está usando esto de forma gratuita, así que tal vez le dé a los desarrolladores el beneficio de la duda antes de hacer una rabieta.

@chrisdothtml

La advertencia en cuestión no rompe nada, pero advierte al usuario de algo que se eliminará en la próxima versión principal.

Contamina las pruebas y la consola, lo que es levemente molesto.

La mangosta es horrible. También el peor sitio de documentación que vi en bibliotecas tan populares. ¡Qué lástima!

Está siendo descortés, lo que también es un poco molesto, pero tiene un punto muy válido con respecto a la documentación de Mongoose. No es la peor documentación de la historia, pero realmente podría mejorarse.

El hecho de que mongoose reenvía la API del cliente mongo. que funciona de una manera muy diferente, hace que el uso y la documentación de Mongoose sean confusos.

Una posible solución para esto sería:

• deja de hacerlo
• elimine la documentación para los métodos del cliente Mongo
• proporcionar una forma de compartir la conexión entre el cliente oficial y Mongoose

También sugeriría mejorar la capacidad de búsqueda de documentos dividiéndolos en varias páginas y brindando más información a los nuevos usuarios sobre lo que Mongoose está haciendo realmente para lograr algunos de los resultados.

Tuve este error, pero desapareció después de agregar la opción {useMongoClient: true}.
Uso Debian 9, versión de prueba, con MongoDb ver. 3.2.11 y mangosta ver. 4.10.4.
Tengo el mensaje 'Conectado a MongoDB' (ver código en Typescript a continuación), todo funciona perfectamente.

(<cualquiera>mangosta).Promise = global.Promise;
mongoose.connect(process.env.MONGODB_URI, {useMongoClient: true});
const db = mangosta.conexión;
db.on('error', console.error.bind(console, 'error de conexión:'));
db.once('abrir', () => {
console.log('Conectado a MongoDB');
establecer rutas (aplicación);
app.get('/*', function(req, res) {
res.sendFile(ruta.join(__dirname, '../public/index.html'));
});
app.listen(app.get('puerto'), () => {
console.log('MyApp escuchando en el puerto' + app.get('port'));
});
});

Simplemente desinstale la versión actual de mongoose que tiene e instale la versión inferior npm install [email protected] --save . No hay necesidad de hacer nada más, esto definitivamente funcionará para usted.

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

Esto resolvió mi problema. Pero tuve otra advertencia después de hacer este cambio.

DeprecationWarning: Mongoose: mpromise (la biblioteca de promesas predeterminada de mongoose) está en desuso, conecte su propia biblioteca de promesas en su lugar: http://mongoosejs.com/docs/promises.html

Este código resuelve todas las advertencias de obsolescencia:
```javascript
mangosta.Promesa = global.Promesa;
mangosta.conectar(uri, {
KeepAlive: cierto,
intentos de reconexión: Número.MAX_VALUE,
useMongoClient: verdadero
});
````
Más información en el enlace -> http://mongoosejs.com/docs/connections.html#use -mongo-client

@bricss ¡Fantástico! ¡Gracias!

@bricss Me alegraste el día.

alguien ganó una insignia de héroe...

editar: @bricss Eliminó las advertencias de obsolescencia para mí, pero no pude recuperar datos de mis sandboxes de mLab. Puede ser porque están usando una versión anterior de MongoDB. Intentaré comprobarlo más tarde.

editar: @bricss Ahora funciona correctamente con la última versión de mongoose 4.11.9 y una conexión a Cosmos DB en Azure.

@bricss : ¡Ladrillos bien hechos! Funcionó para mí a pesar de que estoy usando una versión muy antigua de mongodb en mi local :+1:

@bricss ¡Impresionante! Pero podría considerar poner un número más pequeño para "reconnectTries". No desea pasar todo el día volviendo a conectarse si hay un problema con su base de datos.

La solución de @afoke funcionó para mí, solo cuando declaro explícitamente la base de datos en la cadena de conexión, es decir mongodb://localhost:27017/test pero no mongodb://localhost:27017

¿Puedo crear una conexión a 2 bases de datos sin esta advertencia? Necesito usar mis modelos con diferentes bases de datos.

Al usar mongoose v^4.11.6, cuando se agregaba useMongoClient la advertencia desaparecía.

const uri = "http://blablabla.blo/blaDB"; mongoose.Promise = global.Promise; mongoose.connection.on('error', (err) => { console.error( Error de conexión de Mongoose: ${err}`);
proceso.salir(1);
});
mongoose.connect(uri, {useMongoClient: true});

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

conectarse a la base de datos de esta manera resuelve el problema:
mongoose.connect(url,{usuario:'nombre de usuario',contraseña:'micontraseña',useMongoClient:true});

¿Estos errores causarán problemas, por ejemplo, en seguridad?

No aparece más advertencia de "obsoleto" si uso esta sintaxis 🎉

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

Me enfrenté a la misma advertencia de desaprobación que se muestra a continuación:
(nodo: 2300) Advertencia de desuso: open() está en desuso en mongoose >= 4.11.0, use openUri() en su lugar, o configure la opción useMongoClient si usa connect() o createConnection() . Consulte http://mongoosejs.com/docs/connections.html#use-mongo-client

Solución

Intenté lo siguiente y funciona bien. No da advertencias de desaprobación.

mongoose.connect('mongodb://127.0.0.1:27017/nombre-de-su-base-de-datos', { useMongoClient: true, promiseLibrary: global.Promise });

Espero que esto ayude a todos los que enfrentan este problema.

Tengo el mismo problema, pero cuando intento conectarme al servicio Mongo Atlas, simplemente no se conecta con la opción {useMo ngoClient:true } y sin ella, la conexión ya no se ejecuta.

¿Alguien con el mismo problema?

Resolví mi problema simplemente cambiando mongoose.connect a mongoose.createConnection

mongoose.createConnection(config.uri, (err) => {
si (err) {
console.log('NO se pudo conectar a la base de datos: ', err);
} demás {
console.log('Conectado a la base de datos: ' + config.db);
}
});

Resolví este problema así (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);
});