Connection

• Connection()
• Connection.prototype.asPromise()
• Connection.prototype.client
• Connection.prototype.close()
• Connection.prototype.collection()
• Connection.prototype.collections
• Connection.prototype.config
• Connection.prototype.createCollection()
• Connection.prototype.createCollections()
• Connection.prototype.db
• Connection.prototype.deleteModel()
• Connection.prototype.destroy()
• Connection.prototype.dropCollection()
• Connection.prototype.dropDatabase()
• Connection.prototype.get()
• Connection.prototype.getClient()
• Connection.prototype.host
• Connection.prototype.id
• Connection.prototype.model()
• Connection.prototype.modelNames()
• Connection.prototype.models
• Connection.prototype.name
• Connection.prototype.openUri()
• Connection.prototype.pass
• Connection.prototype.plugin()
• Connection.prototype.plugins
• Connection.prototype.port
• Connection.prototype.readyState
• Connection.prototype.removeDb()
• Connection.prototype.set()
• Connection.prototype.setClient()
• Connection.prototype.startSession()
• Connection.prototype.syncIndexes()
• Connection.prototype.transaction()
• Connection.prototype.useDb()
• Connection.prototype.user
• Connection.prototype.watch()

Connection()

Parameters:

• base «Mongoose» a mongoose instance

Inherits:

• «NodeJS EventEmitter»

Connection.prototype.asPromise()

Returns:

• «Promise»

const conn = await mongoose.createConnection('mongodb://127.0.0.1:27017/test').
  asPromise();
conn.readyState; // 1, means Mongoose is connected
  

Connection.prototype.client

Type:

• «property»

Connection.prototype.close()

Parameters:

• [force] «Boolean» optional

Returns:

• «Promise»

Connection.prototype.collection()

Parameters:

• name «String» of the collection
• [options] «Object» optional collection options

Returns:

• «Collection» collection instance

Connection.prototype.collections

Type:

• «property»

Connection.prototype.config

Type:

• «property»

Connection.prototype.createCollection()

Parameters:

• collection «string» The collection to create
• [options] «Object» see MongoDB driver docs

Returns:

• «Promise»

Connection.prototype.createCollections()

Parameters:

• continueOnError «Boolean» When true, will continue to create collections and create a new error class for the collections that errored.

Connection.prototype.db

Type:

• «property»

Connection.prototype.deleteModel()

Parameters:

• name «String|RegExp» if string, the name of the model to remove. If regexp, removes all models whose name matches the regexp.

Returns:

• «Connection» this

conn.model('User', new Schema({ name: String }));
console.log(conn.model('User')); // Model object
conn.deleteModel('User');
console.log(conn.model('User')); // undefined
// Usually useful in a Mocha `afterEach()` hook
afterEach(function() {
  conn.deleteModel(/.+/); // Delete every model
  

Connection.prototype.destroy()

Parameters:

• [force] «Boolean»

Connection.prototype.dropCollection()

Parameters:

• collection «string» The collection to delete

Returns:

• «Promise»

Connection.prototype.dropDatabase()

Returns:

• «Promise»

const conn = mongoose.createConnection('mongodb://127.0.0.1:27017/mydb');
// Deletes the entire 'mydb' database
await conn.dropDatabase();
  

Connection.prototype.get()

Parameters:

• key «String»

conn.get('test'); // returns the 'test' value
  

Connection.prototype.getClient()

Returns:

• «MongoClient»

const conn = await mongoose.createConnection('mongodb://127.0.0.1:27017/test').
  asPromise();
conn.getClient(); // MongoClient { ... }
  

Connection.prototype.host

Type:

• «property»

mongoose.createConnection('mongodb://127.0.0.1:27017/mydb').host; // "127.0.0.1"
  

Connection.prototype.id

Type:

• «property»

// The default connection has `id = 0`
mongoose.connection.id; // 0
// If you create a new connection, Mongoose increments id
const conn = mongoose.createConnection();
conn.id; // 1
  

Connection.prototype.model()

Parameters:

• name «String|Function» the model name or class extending Model
• [schema] «Schema» a schema. necessary when defining a model
• [collection] «String» name of mongodb collection (optional) if not given it will be induced from model name
• [options] «Object»
• [options.overwriteModels=false] «Boolean» If true, overwrite existing models with the same name to avoid OverwriteModelError

Returns:

• «Model» The compiled model

See:

• Mongoose#model

const mongoose = require('mongoose');
const db = mongoose.createConnection(..);
db.model('Venue', new Schema(..));
const Ticket = db.model('Ticket', new Schema(..));
const Venue = db.model('Venue');
When no collection argument is passed, Mongoose produces a collection name by passing the model name to the utils.toCollectionName method. This method pluralizes the name. If you don't like this behavior, either pass a collection name or set your schemas collection name option.
        Example:
const schema = new Schema({ name: String }, { collection: 'actor' });
// or
schema.set('collection', 'actor');
// or
const collectionName = 'actor'
const M = conn.model('Actor', schema, collectionName)
  

Connection.prototype.modelNames()

Returns:

• «Array[String]»

Connection.prototype.models

Type:

• «property»

const conn = mongoose.createConnection();
const Test = conn.model('Test', mongoose.Schema({ name: String }));
Object.keys(conn.models).length; // 1
conn.models.Test === Test; // true
  

Connection.prototype.name

Type:

• «property»

mongoose.createConnection('mongodb://127.0.0.1:27017/mydb').name; // "mydb"
  

Connection.prototype.openUri()

Parameters:

• uri «String» The URI to connect with.
• [options] «Object» Passed on to MongoClient.connect
• [options.bufferCommands=true] «Boolean» Mongoose specific option. Set to false to disable buffering on all models associated with this connection.
• [options.bufferTimeoutMS=10000] «Number» Mongoose specific option. If bufferCommands is true, Mongoose will throw an error after bufferTimeoutMS if the operation is still buffered.
• [options.dbName] «String» The name of the database we want to use. If not provided, use database name from connection string.
• [options.user] «String» username for authentication, equivalent to options.auth.user . Maintained for backwards compatibility.
• [options.pass] «String» password for authentication, equivalent to options.auth.password . Maintained for backwards compatibility.
• [options.maxPoolSize=100] «Number» The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See Slow Trains in MongoDB and Node.js .
• [options.minPoolSize=0] «Number» The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See Slow Trains in MongoDB and Node.js .
• [options.serverSelectionTimeoutMS] «Number» If useUnifiedTopology = true , the MongoDB driver will try to find a server to send any given operation to, and keep retrying for serverSelectionTimeoutMS milliseconds before erroring out. If not set, the MongoDB driver defaults to using 30000 (30 seconds).
• [options.heartbeatFrequencyMS] «Number» If useUnifiedTopology = true , the MongoDB driver sends a heartbeat every heartbeatFrequencyMS to check on the status of the connection. A heartbeat is subject to serverSelectionTimeoutMS , so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a 'disconnected' event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits 'disconnected' . We recommend you do not set this setting below 1000, too many heartbeats can lead to performance degradation.
• [options.autoIndex=true] «Boolean» Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
• [options.promiseLibrary] «Class» Sets the underlying driver's promise library .
• [options.socketTimeoutMS=0] «Number» How long the MongoDB driver will wait before killing a socket due to inactivity after initial connection . A socket may be inactive because of either no activity or a long-running operation. socketTimeoutMS defaults to 0, which means Node.js will not time out the socket due to inactivity. This option is passed to Node.js socket#setTimeout() function after the MongoDB driver successfully completes.
• [options.family=0] «Number» Passed transparently to Node.js' dns.lookup() function. May be either 0, 4 , or 6 . 4 means use IPv4 only, 6 means use IPv6 only, 0` means try both.
• [options.autoCreate=false] «Boolean» Set to true to make Mongoose automatically call createCollection() on every model created on this connection.

Connection.prototype.pass

Type:

• «property»

mongoose.createConnection('mongodb://val:psw@127.0.0.1:27017/mydb').pass; // "psw"
  

Connection.prototype.plugin()

Parameters:

• fn «Function» plugin callback
• [opts] «Object» optional options

Returns:

• «Connection» this

See:

• plugins

const db = mongoose.createConnection('mongodb://127.0.0.1:27017/mydb');
db.plugin(() => console.log('Applied'));
db.plugins.length; // 1
db.model('Test', new Schema({})); // Prints "Applied"
  

Connection.prototype.plugins

Type:

• «property»

const db = mongoose.createConnection('mongodb://127.0.0.1:27017/mydb');
db.plugin(() => console.log('Applied'));
db.plugins.length; // 1
db.model('Test', new Schema({})); // Prints "Applied"
  

Connection.prototype.port

Type:

• «property»

mongoose.createConnection('mongodb://127.0.0.1:27017/mydb').port; // 27017
  

Connection.prototype.readyState

Type:

• «property»

conn.on('connected', callback);
conn.on('disconnected', callback);
  

Connection.prototype.removeDb()

Parameters:

• name «String» The database name

Returns:

• «Connection» this

// Connect to `initialdb` first
const conn = await mongoose.createConnection('mongodb://127.0.0.1:27017/initialdb').asPromise();
// Creates an un-cached connection to `mydb`
const db = conn.useDb('mydb');
// Closes `db`, and removes `db` from `conn.relatedDbs` and `conn.otherDbs`
await conn.removeDb('mydb');
  

Connection.prototype.set()

Parameters:

• key «String»
• val «Any»

conn.set('test', 'foo');
conn.get('test'); // 'foo'
conn.options.test; // 'foo'
  

Connection.prototype.setClient()

Parameters:

• client «MongClient» The Client to set to be used.

Returns:

• «Connection» this

const client = await mongodb.MongoClient.connect('mongodb://127.0.0.1:27017/test');
const conn = mongoose.createConnection().setClient(client);
conn.getClient(); // MongoClient { ... }
conn.readyState; // 1, means 'CONNECTED'
  

Connection.prototype.startSession()

Parameters:

• [options] «Object» see the mongodb driver options
• [options.causalConsistency=true] «Boolean» set to false to disable causal consistency

Returns:

• «Promise<ClientSession>» promise that resolves to a MongoDB driver ClientSession

const session = await conn.startSession();
let doc = await Person.findOne({ name: 'Ned Stark' }, null, { session });
await doc.remove();
// `doc` will always be null, even if reading from a replica set
// secondary. Without causal consistency, it is possible to
// get a doc back from the below query if the query reads from a
// secondary that is experiencing replication lag.
doc = await Person.findOne({ name: 'Ned Stark' }, null, { session, readPreference: 'secondary' });
  

Connection.prototype.syncIndexes()

Parameters:

• [options] «Object»
• [options.continueOnError] «Boolean» false by default. If set to true , mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.

Returns:

• «Promise<Object>» Returns a Promise, when the Promise resolves the value is a list of the dropped indexes.

Connection.prototype.transaction()

Parameters:

• fn «Function» Function to execute in a transaction
• [options] «[object Object]» Optional settings for the transaction

Returns:

• «Promise<Any>» promise that is fulfilled if Mongoose successfully committed the transaction, or rejects if the transaction was aborted or if Mongoose failed to commit the transaction. If fulfilled, the promise resolves to a MongoDB command result.

const doc = new Person({ name: 'Will Riker' });
await db.transaction(async function setRank(session) {
  doc.rank = 'Captain';
  await doc.save({ session });
  doc.isNew; // false
  // Throw an error to abort the transaction
  throw new Error('Oops!');
},{ readPreference: 'primary' }).catch(() => {});
// true, `transaction()` reset the document's state because the
// transaction was aborted.
doc.isNew;
  

Connection.prototype.useDb()

Parameters:

• name «String» The database name
• [options] «Object»
• [options.useCache=false] «Boolean» If true, cache results so calling useDb() multiple times with the same name only creates 1 connection object.
• [options.noListener=false] «Boolean» If true, the connection object will not make the db listen to events on the original connection. See issue #9961 .

Returns:

• «Connection» New Connection Object

// Connect to `initialdb` first
const conn = await mongoose.createConnection('mongodb://127.0.0.1:27017/initialdb').asPromise();
// Creates an un-cached connection to `mydb`
const db = conn.useDb('mydb');
// Creates a cached connection to `mydb2`. All calls to `conn.useDb('mydb2', { useCache: true })` will return the same
// connection instance as opposed to creating a new connection instance
const db2 = conn.useDb('mydb2', { useCache: true });
  

Connection.prototype.user

Type:

• «property»

mongoose.createConnection('mongodb://val:psw@127.0.0.1:27017/mydb').user; // "val"
  

Connection.prototype.watch()

Parameters:

• [pipeline] «Array»
• [options] «Object» passed without changes to the MongoDB driver's Db#watch() function

Returns:

• «ChangeStream» mongoose-specific change stream wrapper, inherits from EventEmitter

const User = conn.model('User', new Schema({ name: String }));