Подключения

Вы можете подключиться к MongoDB с помощью метода mongoose.connect().

mongoose.connect('mongodb://127.0.0.1:27017/myapp');

Это минимальные настройки для подключения к базе данных myapp, работающей локально на стандартном порту (27017). Для локальных баз данных MongoDB мы рекомендуем использовать 127.0.0.1 вместо localhost. Это связано с тем, что Node.js 18 и выше предпочитают адреса IPv6, что означает, что на многих машинах Node.js будет разрешать localhost в адрес IPv6 ::1, и Mongoose не сможет подключиться, если экземпляр mongodb не запущен с включённым IPv6.

Вы также можете указать несколько дополнительных параметров в uri:

mongoose.connect('mongodb://username:password@host:port/database?options...');

Подробнее см. спецификацию строки подключения MongoDB на сайте MongoDB.

Буферизация операций

Mongoose позволяет сразу начать использовать модели, не дожидаясь установления соединения с MongoDB.

mongoose.connect('mongodb://127.0.0.1:27017/myapp');
const MyModel = mongoose.model('Test', new Schema({ name: String }));
// Works
await MyModel.findOne();

Это потому, что Mongoose буферизует вызовы функций моделей внутри. Эта буферизация удобна, но также является распространённой причиной путаницы. Mongoose по умолчанию не будет генерировать ошибки, если вы используете модель без подключения.

const MyModel = mongoose.model('Test', new Schema({ name: String }));
const promise = MyModel.findOne();

setTimeout(function() {
  mongoose.connect('mongodb://127.0.0.1:27017/myapp');
}, 60000);

// Will just hang until mongoose successfully connects
await promise;

Чтобы отключить буферизацию, выключите опцию bufferCommands в вашей схеме. Если у вас bufferCommands включена, а соединение зависает, попробуйте выключить bufferCommands и посмотрите, правильно ли вы установили соединение. Вы также можете отключить bufferCommands глобально:

mongoose.set('bufferCommands', false);

Обратите внимание, что буферизация также отвечает за ожидание создания коллекций Mongoose, если вы используете опцию autoCreate. Если вы отключили буферизацию, вам также следует отключить опцию autoCreate и использовать createCollection() для создания заполненных коллекций или коллекций с правилами сортировки.

const schema = new Schema({
  name: String
}, {
  capped: { size: 1024 },
  bufferCommands: false,
  autoCreate: false // disable `autoCreate` since `bufferCommands` is false
});

const Model = mongoose.model('Test', schema);
// Explicitly create the collection before using it
// so the collection is capped.
await Model.createCollection();

Обработка ошибок

Существует два типа ошибок, которые могут возникнуть при подключении к Mongoose.

• Ошибка при первоначальном подключении: Если первоначальное подключение завершится неудачно, Mongoose сгенерирует событие 'error' и обещание mongoose.connect() вернётся с отказом. Однако Mongoose не будет автоматически пытаться переподключиться.
• Ошибка после установления первоначального подключения: Mongoose попытается переподключиться и сгенерирует событие 'error'.

Для обработки ошибок при первоначальном подключении вы должны использовать .catch() или try/catch с async/await.

mongoose.connect('mongodb://127.0.0.1:27017/test').
  catch(error => handleError(error));

// Or:
try {
  await mongoose.connect('mongodb://127.0.0.1:27017/test');
} catch (error) {
  handleError(error);
}

Для обработки ошибок после установления первоначального подключения вы должны прослушивать события ошибок на подключении. Однако вы по-прежнему должны обрабатывать ошибки первоначального подключения, как показано выше.

mongoose.connection.on('error', err => {
  logError(err);
});

Обратите внимание, что Mongoose не обязательно сгенерирует событие 'error', если потеряет соединение с MongoDB. Вы должны прослушивать событие disconnected для отслеживания, когда Mongoose отключится от MongoDB.

Параметры

Метод connect также принимает объект options, который будет передан в базовый драйвер MongoDB.

mongoose.connect(uri, options);

Полный список параметров можно найти в документации драйвера MongoDB Node.js для MongoClientOptions по адресу ссылке. Mongoose передаёт параметры драйверу без изменений, за исключением нескольких случаев, описанных ниже.

• bufferCommands - Это специфичный для Mongoose параметр (не передаётся в драйвер MongoDB), который отключает механизм буферизации Mongoose
• user/pass - Имя пользователя и пароль для аутентификации. Эти параметры специфичны для Mongoose, они эквивалентны параметрам auth.username и auth.password драйвера MongoDB.
• autoIndex - По умолчанию Mongoose автоматически создаст индексы, определённые в вашей схеме, при подключении. Это отлично подходит для разработки, но не идеально для больших производственных развертываний, поскольку создание индексов может ухудшить производительность. Если вы установите autoIndex в false, Mongoose не будет автоматически создавать индексы для любой модели, связанной с этим подключением.
• dbName - Указывает, к какой базе данных подключиться, и переопределяет любую базу данных, указанную в строке подключения. Это полезно, если вы не можете указать базу данных по умолчанию в строке подключения, как в случае с некоторыми синтаксисами подключения mongodb+srv.

Ниже приведены некоторые параметры, важные для настройки Mongoose.

• promiseLibrary - Устанавливает библиотеку обещаний базового драйвера.
• maxPoolSize - Максимальное количество сокетов, которые драйвер MongoDB будет держать открытыми для этого подключения. По умолчанию maxPoolSize равно 100. Имейте в виду, что MongoDB позволяет только одну операцию на сокет за раз, поэтому вам может потребоваться увеличить это значение, если вы обнаружите несколько медленных запросов, которые блокируют более быстрые запросы. См. Slow Trains in MongoDB and Node.js. Вы можете захотеть уменьшить maxPoolSize при возникновении ограничений на подключения на Atlas.
• minPoolSize - Минимальное количество сокетов, которые драйвер MongoDB будет держать открытыми для этого подключения. Драйвер MongoDB может закрывать сокеты, которые были неактивны некоторое время. Вы можете увеличить minPoolSize если ожидаете, что ваше приложение будет долго простаивать, и хотите убедиться, что сокеты остаются открытыми, чтобы избежать медленных запросов, когда активность увеличится.
• socketTimeoutMS - Время ожидания драйвера MongoDB перед закрытием сокета из-за отсутствия активности после первоначального подключения. Сокет может быть неактивным из-за отсутствия активности или долгой операции. socketTimeoutMS по умолчанию равно 0, что означает, что Node.js не будет отключать сокет из-за отсутствия активности. Этот параметр передаётся в функцию Node.js socket#setTimeout() после успешного завершения драйвером MongoDB.
• family - Использовать IPv4 или IPv6 для подключения. Этот параметр передаётся в функцию Node.js dns.lookup(). Если вы не укажете этот параметр, драйвер MongoDB сначала попытается подключиться по IPv6, а затем по IPv4, если подключение по IPv6 не удастся. Если вызов mongoose.connect(uri) занимает много времени, попробуйте mongoose.connect(uri, { family: 4 })
• authSource - База данных, используемая при аутентификации с user и pass. В MongoDB пользователи ограничены базой данных. Если у вас возникают неожиданные ошибки входа в систему, вам может потребоваться установить этот параметр.
• serverSelectionTimeoutMS - Драйвер MongoDB попытается найти сервер для отправки каждой операции и продолжить попытки в течение serverSelectionTimeoutMS миллисекунд. Если не указано, драйвер MongoDB использует 30000 (30 секунд).
• heartbeatFrequencyMS - Драйвер MongoDB отправляет контрольную точку каждые heartbeatFrequencyMS миллисекунд, чтобы проверить состояние подключения. Контрольная точка подвержена serverSelectionTimeoutMS, поэтому драйвер MongoDB будет повторно пытаться выполнить не удавшиеся контрольные точки в течение 30 секунд по умолчанию. Mongoose генерирует событие 'disconnected' только после неудачи контрольной точки, поэтому вы можете захотеть уменьшить это значение, чтобы сократить время между сбоем вашего сервера и генерированием Mongoose события 'disconnected'. Мы рекомендуем не устанавливать это значение ниже 1000, так как слишком частые контрольные точки могут привести к ухудшению производительности.

serverSelectionTimeoutMS

Параметр serverSelectionTimeoutMS очень важен: он управляет временем, в течение которого драйвер MongoDB Node.js будет пытаться повторить операцию, прежде чем вернуть ошибку. Это включает первоначальное подключение, как await mongoose.connect(), а также любые операции, которые отправляют запросы в MongoDB, как save() или find().

По умолчанию serverSelectionTimeoutMS равно 30000 (30 секунд). Это означает, что, например, если вы вызовете mongoose.connect(), когда ваш автономный сервер MongoDB недоступен, ваш вызов mongoose.connect() вернёт ошибку только после 30 секунд.

// Throws an error "getaddrinfo ENOTFOUND doesnt.exist" after 30 seconds
await mongoose.connect('mongodb://doesnt.exist:27017/test');

Аналогично, если ваш автономный сервер MongoDB выйдет из строя после первоначального подключения, любые вызовы find() или save() завершатся ошибкой через 30 секунд, если ваш сервер MongoDB не будет перезапущен.

Хотя 30 секунд кажутся большим временем, serverSelectionTimeoutMS означает, что вы вряд ли столкнётесь с перебоями во время переключения на резервную копию. Если вы потеряете основной сервер репликации, драйвер MongoDB Node обеспечит выполнение любых операций, отправленных вами во время выборочного избрания репликации, при условии, что выборочное избрание репликации займет меньше serverSelectionTimeoutMS.

Чтобы получить более быструю обратную связь об ошибках подключения, вы можете уменьшить serverSelectionTimeoutMS до 5000, как показано ниже. Мы не рекомендуем уменьшать serverSelectionTimeoutMS , если вы не используете автономный сервер MongoDB, а не набор репликации, или если вы используете серверless платформу, например, AWS Lambda.

mongoose.connect(uri, {
  serverSelectionTimeoutMS: 5000
});

Нет возможности настроить serverSelectionTimeoutMS отдельно для mongoose.connect() и для запросов. Если вы хотите уменьшить serverSelectionTimeoutMS для запросов и других операций, но при этом продолжить повторную попытку mongoose.connect() на более длительное время, вам придётся самим повторно пытаться выполнить вызовы connect() с помощью цикла for или с помощью инструмента, такого как p-retry ссылка.

const serverSelectionTimeoutMS = 5000;

// Prints "Failed 0", "Failed 1", "Failed 2" and then throws an
// error. Exits after approximately 15 seconds.
for (let i = 0; i < 3; ++i) {
  try {
    await mongoose.connect('mongodb://doesnt.exist:27017/test', {
      serverSelectionTimeoutMS
    });
    break;
  } catch (err) {
    console.log('Failed', i);
    if (i >= 2) {
      throw err;
    }
  }
}

Обратный вызов

Функция connect() также принимает параметр обратного вызова и возвращает обещание.

mongoose.connect(uri, options, function(error) {
  // Check error in initial connection. There is no 2nd param to the callback.
});

// Or using promises
mongoose.connect(uri, options).then(
  () => { /** ready to use. The `mongoose.connect()` promise resolves to mongoose instance. */ },
  err => { /** handle initial connection error */ }
);

Параметры строки подключения

Вы также можете указать параметры драйвера в строке подключения в виде параметров в строке запроса части URI. Это относится только к параметрам, передаваемым в драйвер MongoDB. Вы не можете установить специфичные для Mongoose параметры, такие как bufferCommands в строке запроса.

mongoose.connect('mongodb://127.0.0.1:27017/test?socketTimeoutMS=1000&bufferCommands=false&authSource=otherdb');
// The above is equivalent to:
mongoose.connect('mongodb://127.0.0.1:27017/test', {
  socketTimeoutMS: 1000
  // Note that mongoose will **not** pull `bufferCommands` from the query string
});

Недостатком использования опций в строке запроса является то, что опции строки запроса сложнее читать. Преимущество заключается в том, что вам нужна только одна конфигурационная опция, URI, а не отдельные опции для socketTimeoutMS, и т. д. Лучшей практикой является размещение опций, которые, скорее всего, будут отличаться между разработкой и производством, таких как replicaSet или ssl, в строке подключения, а опции, которые должны оставаться постоянными, такие как socketTimeoutMS или maxPoolSize, в объекте опций.

В документации MongoDB есть полный список поддерживаемых опций строки подключения. Ниже приведены некоторые опции, которые часто полезно устанавливать в строке подключения, потому что они тесно связаны с именем хоста и информацией об аутентификации.

• authSource — база данных, используемая при аутентификации с user и pass. В MongoDB пользователи ограничены базой данных. Если у вас возникают неожиданные ошибки входа в систему, вам может потребоваться установить эту опцию.
• family — использовать IPv4 или IPv6 для подключения. Эта опция передается функции Node.js' dns.lookup(). Если вы не укажете эту опцию, драйвер MongoDB сначала попробует IPv6, а затем IPv4, если IPv6 не удастся. Если ваш вызов mongoose.connect(uri) занимает много времени, попробуйте mongoose.connect(uri, { family: 4 })

События подключения

Подключения наследуются от класса Node.js' EventEmitter и генерируют события, когда что-то происходит с подключением, например, потеря соединения с сервером MongoDB. Ниже приведен список событий, которые может генерировать подключение.

• connecting: Срабатывает, когда Mongoose начинает первоначальное подключение к серверу MongoDB
• connected: Срабатывает, когда Mongoose успешно выполняет первоначальное подключение к серверу MongoDB или когда Mongoose повторно подключается после потери соединения. Может срабатывать несколько раз, если Mongoose теряет соединение.
• open: Срабатывает после выполнения 'connected' и onOpen для всех моделей этого подключения.
• disconnecting: Ваше приложение вызвало Connection#close() для отключения от MongoDB
• disconnected: Срабатывает, когда Mongoose потерял соединение с сервером MongoDB. Это событие может быть вызвано явным закрытием подключения вашим кодом, сбоем сервера базы данных или проблемами с сетевым подключением.
• close: Срабатывает после успешного закрытия соединения с помощью Connection#close(). Если вы вызываете conn.close(), вы получите как событие 'disconnected', так и событие 'close'.
• reconnected: Срабатывает, если Mongoose потерял соединение с MongoDB и успешно восстановил его. Mongoose пытается автоматически повторно подключиться, когда теряет соединение с базой данных.
• error: Срабатывает, если при подключении возникла ошибка, например, parseError из-за некорректных данных или полезной нагрузки, превышающей 16 МБ.
• fullsetup: Срабатывает при подключении к репликации набора, и Mongoose успешно подключился к первичному и по крайней мере к одному вторичному серверу.
• all: Срабатывает при подключении к репликации набора, и Mongoose успешно подключился ко всем серверам, указанным в строке подключения.

При подключении к одному серверу MongoDB («standalone»), Mongoose сгенерирует 'disconnected', если соединение с автономным сервером прервётся, и 'connected', если подключение к автономному серверу будет успешно установлено. В репликации набора Mongoose сгенерирует 'disconnected', если связь с первичным сервером репликации набора будет потеряна, и 'connected', если удастся повторно подключиться к первичному серверу репликации набора.

Примечание о keepAlive

До Mongoose 5.2.0 вам нужно было включить опцию keepAlive для инициирования TCP keepalive, чтобы предотвратить ошибки "connection closed". Однако keepAlive по умолчанию включен в Mongoose 5.2.0, а опция keepAlive устарела начиная с Mongoose 7.2.0. Пожалуйста, удалите опции keepAlive и keepAliveInitialDelay из ваших подключений Mongoose.

Подключения к репликации наборов

Для подключения к репликации набора вы передаете список хостов, разделенных запятыми, для подключения, а не один хост.

mongoose.connect('mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]' [, options]);

Например:

mongoose.connect('mongodb://user:pw@host1.com:27017,host2.com:27017,host3.com:27017/testdb');

Для подключения к одному узлу репликации набора укажите опцию replicaSet.

mongoose.connect('mongodb://host1:port1/?replicaSet=rsName');

Выбор сервера

Внутренний драйвер MongoDB использует процесс, известный как выбор сервера, для подключения к MongoDB и отправки операций в MongoDB. Если драйвер MongoDB не может найти сервер для отправки операции после serverSelectionTimeoutMS, вы получите следующую ошибку:

MongoTimeoutError: Server selection timed out after 30000 ms

Вы можете настроить таймаут, используя опцию serverSelectionTimeoutMS для mongoose.connect():

mongoose.connect(uri, {
  serverSelectionTimeoutMS: 5000 // Timeout after 5s instead of 30s
});

У объекта MongoTimeoutError есть свойство reason, которое объясняет, почему таймаут выбора сервера истек. Например, если вы подключаетесь к автономному серверу с неправильным паролем, reason будет содержать ошибку «Аутентификация не удалась».

const mongoose = require('mongoose');

const uri = 'mongodb+srv://username:badpw@cluster0-OMITTED.mongodb.net/' +
  'test?retryWrites=true&w=majority';
// Prints "MongoServerError: bad auth Authentication failed."
mongoose.connect(uri, {
  serverSelectionTimeoutMS: 5000
}).catch(err => console.log(err.reason));

Имена хостов репликации набора

Репликации наборов MongoDB полагаются на возможность надежного определения доменного имени для каждого члена.
В Linux и OSX сервер MongoDB использует вывод команды hostname для определения доменного имени, которое необходимо сообщить репликации набора. Это может привести к путанице ошибок, если вы подключаетесь к удаленной репликации набора MongoDB, работающей на машине, которая сообщает своё hostname как localhost:

// Can get this error even if your connection string doesn't include
// `localhost` if `rs.conf()` reports that one replica set member has
// `localhost` as its host name.
MongooseServerSelectionError: connect ECONNREFUSED localhost:27017

Если у вас возникла подобная ошибка, подключитесь к репликации набора с помощью командной оболочки и выполните команду rs.conf() для проверки имен хостов каждого члена репликации набора. Следуйте инструкциям на странице изменения имени хоста члена репликации набора.

Вы также можете проверить свойство reason.servers объекта MongooseServerSelectionError, чтобы увидеть, как драйвер MongoDB Node видит состояние вашей репликации набора. Свойство reason.servers содержит карту описаний серверов.

if (err.name === 'MongooseServerSelectionError') {
  // Contains a Map describing the state of your replica set. For example:
  // Map(1) {
  //   'localhost:27017' => ServerDescription {
  //     address: 'localhost:27017',
  //     type: 'Unknown',
  //     ...
  //   }
  // }
  console.log(err.reason.servers);
}

Поддержка нескольких mongos

Вы также можете подключиться к нескольким экземплярам mongos для обеспечения высокой доступности в фрагментированной кластере. В Mongoose 5.x вам не нужно передавать никаких специальных опций для подключения к нескольким mongos.

// Connect to 2 mongos servers
mongoose.connect('mongodb://mongosA:27501,mongosB:27501', cb);

Множественные подключения

До сих пор мы видели, как подключаться к MongoDB, используя стандартное подключение Mongoose. Mongoose создает стандартное подключение, когда вы вызываете mongoose.connect(). Вы можете получить доступ к стандартному подключению, используя mongoose.connection.

Вам могут потребоваться несколько подключений к MongoDB по нескольким причинам. Одна из них — наличие нескольких баз данных или нескольких кластеров MongoDB. Другая — решение проблем с медленными операциями. Функция mongoose.createConnection() принимает те же аргументы, что и mongoose.connect(), и возвращает новое подключение.

const conn = mongoose.createConnection('mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]', options);

Этот объект подключения затем используется для создания и получения моделей. Модели всегда привязаны к одному подключению.

const UserModel = conn.model('User', userSchema);

Если вы используете несколько подключений, убедитесь, что вы экспортируете схемы, а не модели. Экспорт модели из файла называется паттерном экспорта модели. Паттерн экспорта модели ограничен, поскольку вы можете использовать только одно подключение.

const userSchema = new Schema({ name: String, email: String });

// The alternative to the export model pattern is the export schema pattern.
module.exports = userSchema;

// Because if you export a model as shown below, the model will be scoped
// to Mongoose's default connection.
// module.exports = mongoose.model('User', userSchema);

Если вы используете паттерн экспорта схемы, вам все равно необходимо где-то создавать модели. Существует два распространенных паттерна. Первый — экспортировать подключение и регистрировать модели в подключении в файле:

// connections/fast.js
const mongoose = require('mongoose');

const conn = mongoose.createConnection(process.env.MONGODB_URI);
conn.model('User', require('../schemas/user'));

module.exports = conn;

// connections/slow.js
const mongoose = require('mongoose');

const conn = mongoose.createConnection(process.env.MONGODB_URI);
conn.model('User', require('../schemas/user'));
conn.model('PageView', require('../schemas/pageView'));

module.exports = conn;

Другой вариант — регистрировать подключения с помощью инжектора зависимостей или другого паттерна обратного контроля зависимостей (IOC).

const mongoose = require('mongoose');

module.exports = function connectionFactory() {
  const conn = mongoose.createConnection(process.env.MONGODB_URI);

  conn.model('User', require('../schemas/user'));
  conn.model('PageView', require('../schemas/pageView'));

  return conn;
};

Пулы подключений

Каждый connection, созданный с помощью mongoose.connect или mongoose.createConnection, поддерживается внутренним настраиваемым пулом подключений, по умолчанию имеющим максимальный размер 100. Измените размер пула с помощью опций подключения:

// With object options
mongoose.createConnection(uri, { maxPoolSize: 10 });

// With connection string options
const uri = 'mongodb://127.0.0.1:27017/test?maxPoolSize=10';
mongoose.createConnection(uri);

Размер пула подключений важен, потому что MongoDB в настоящее время может обрабатывать только одну операцию на сокет. Таким образом, maxPoolSize выступает как предел количества одновременных операций.

Подключения для многопользовательских систем

В контексте Mongoose многопользовательская архитектура обычно означает случай, когда несколько разных клиентов взаимодействуют с MongoDB через одно приложение Mongoose. Обычно каждый клиент выполняет запросы и выполняет обновления через одно приложение Mongoose, но имеет отдельную базу данных MongoDB в одном кластере MongoDB.

Мы рекомендуем прочитать эту статью о многопользовательском использовании с Mongoose; в ней дается хорошее описание того, как мы определяем многопользовательский доступ, и более подробный обзор рекомендуемых нами паттернов.

Мы рекомендуем два паттерна для многопользовательской работы в Mongoose:

1. Поддерживать один пул подключений, переключаться между арендаторами, используя метод Connection.prototype.useDb().
2. Поддерживать отдельный пул подключений на пользователя, хранить подключения в карте или POJO.

Следующий пример соответствует шаблону (1). Мы рекомендуем шаблон (1) в случаях с небольшим количеством арендаторов или если нагрузка каждого отдельного арендатора невелика (приблизительно < 1 запрос в секунду, все запросы занимают < 10 мс времени обработки в базе данных). Шаблон (1) проще реализовать и поддерживать в производстве, так как используется только 1 пул подключений. Однако при высокой нагрузке могут возникнуть проблемы, когда операции некоторых арендаторов замедляют операции других арендаторов из-за медленных поездов.

const express = require('express');
const mongoose = require('mongoose');

mongoose.connect('mongodb://127.0.0.1:27017/main');
mongoose.set('debug', true);

mongoose.model('User', mongoose.Schema({ name: String }));

const app = express();

app.get('/users/:tenantId', function(req, res) {
  const db = mongoose.connection.useDb(`tenant_${req.params.tenantId}`, {
    // `useCache` tells Mongoose to cache connections by database name, so
    // `mongoose.connection.useDb('foo', { useCache: true })` returns the
    // same reference each time.
    useCache: true
  });
  // Need to register models every time a new connection is created
  if (!db.models['User']) {
    db.model('User', mongoose.Schema({ name: String }));
  }
  console.log('Find users from', db.name);
  db.model('User').find().
    then(users => res.json({ users })).
    catch(err => res.status(500).json({ message: err.message }));
});

app.listen(3000);

Следующий пример соответствует шаблону (2). Шаблон (2) более гибкий и лучше подходит для случаев с > 10 000 арендаторами и > 1 запросом в секунду. Поскольку у каждого арендатора есть отдельный пул подключений, медленные операции одного арендатора окажут минимальное влияние на других. Однако этот шаблон сложнее реализовать и поддерживать в производстве. В частности, MongoDB имеет ограничение на количество открытых подключений, и MongoDB Atlas имеет отдельные ограничения на количество открытых подключений, поэтому необходимо убедиться, что общее количество сокетов в ваших пулах подключений не превышает лимитов MongoDB.

const express = require('express');
const mongoose = require('mongoose');

const tenantIdToConnection = {};

const app = express();

app.get('/users/:tenantId', function(req, res) {
  let initialConnection = Promise.resolve();
  const { tenantId } = req.params;
  if (!tenantIdToConnection[tenantId]) {
    tenantIdToConnection[tenantId] = mongoose.createConnection(`mongodb://127.0.0.1:27017/tenant_${tenantId}`);
    tenantIdToConnection[tenantId].model('User', mongoose.Schema({ name: String }));
    initialConnection = tenantIdToConnection[tenantId].asPromise();
  }
  const db = tenantIdToConnection[tenantId];
  initialConnection.
    then(() => db.model('User').find()).
    then(users => res.json({ users })).
    catch(err => res.status(500).json({ message: err.message }));
});

app.listen(3000);

Далее

Теперь, когда мы рассмотрели подключения, давайте посмотрим на модели.