Схемы

Определение вашей схемы

Всё в Mongoose начинается со схемы. Каждая схема сопоставляется с коллекцией MongoDB и определяет структуру документов в этой коллекции.

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var blogSchema = new Schema({
  title:  String,
  author: String,
  body:   String,
  comments: [{ body: String, date: Date }],
  date: { type: Date, default: Date.now },
  hidden: Boolean,
  meta: {
    votes: Number,
    favs:  Number
  }
});

Если вы хотите добавить дополнительные ключи позже, используйте метод Schema#add.

Каждый ключ в нашейblogSchema определяет свойство в наших документах, которое будет преобразовано в соответствующий тип SchemaType. Например, мы определилиtitle, которое будет преобразовано в тип String SchemaType, иdate, которое будет преобразовано в типDate SchemaType. Ключи также могут быть назначены вложенным объектам, содержащим дальнейшие определения ключей/типов (например, свойство `meta` выше).

Допустимые типы SchemaType:

• String
• Number
• Date
• Buffer
• Boolean
• Mixed
• ObjectId
• Array

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

Создание модели

Чтобы использовать наше определение схемы, нам нужно преобразовать нашу blogSchema в модель Model, с которой мы можем работать. Для этого мы передаём её в mongoose.model(modelName, schema):

var Blog = mongoose.model('Blog', blogSchema);
// ready to go!

Методы экземпляров

Экземпляры Models являются документами. Документы имеют множество собственных встроенных методов экземпляров. Мы также можем определить свои собственные пользовательские методы экземпляров документов.

// define a schema
var animalSchema = new Schema({ name: String, type: String });

// assign a function to the "methods" object of our animalSchema
animalSchema.methods.findSimilarTypes = function(cb) {
  return this.model('Animal').find({ type: this.type }, cb);
};

Теперь у всех нашихanimal экземпляров доступен методfindSimilarTypes.

var Animal = mongoose.model('Animal', animalSchema);
var dog = new Animal({ type: 'dog' });

dog.findSimilarTypes(function(err, dogs) {
  console.log(dogs); // woof
});

Статики

Добавление статических методов к Model также просто. Продолжая с нашей animalSchema:

// assign a function to the "statics" object of our animalSchema
animalSchema.statics.findByName = function(name, cb) {
  return this.find({ name: new RegExp(name, 'i') }, cb);
};

var Animal = mongoose.model('Animal', animalSchema);
Animal.findByName('fido', function(err, animals) {
  console.log(animals);
});

Справочники по запросам

Вы также можете добавить функции-помощники запросов, которые подобны методам экземпляров, но для запросов mongoose. Методы помощников запросов позволяют расширить API цепочечного билдера запросов mongoose здесь.

animalSchema.query.byName = function(name) {
  return this.find({ name: new RegExp(name, 'i') });
};

var Animal = mongoose.model('Animal', animalSchema);
Animal.find().byName('fido').exec(function(err, animals) {
  console.log(animals);
});

Индексы

MongoDB поддерживает вспомогательные индексы. В mongoose мы определяем эти индексы в нашей Schema в пути уровне или в schema уровне. Определение индексов на уровне схемы необходимо при создании составных индексов.

var animalSchema = new Schema({
  name: String,
  type: String,
  tags: { type: [String], index: true } // field level
});

animalSchema.index({ name: 1, type: -1 }); // schema level

mongoose.connect('mongodb://user:pass@localhost:port/database', { autoIndex: false });
// or
mongoose.createConnection('mongodb://user:pass@localhost:port/database', { autoIndex: false });
// or
animalSchema.set('autoIndex', false);
// or
new Schema({..}, { autoIndex: false });

Mongoose выведет событие index в модели, когда индексы закончат построение или произойдёт ошибка.

// Will cause an error because mongodb has an _id index by default that
// is not sparse
animalSchema.index({ _id: 1 }, { sparse: true });
var Animal = mongoose.model('Animal', animalSchema);

Animal.on('index', function(error) {
  // "_id index cannot be sparse"
  console.log(error.message);
});

См. также метод Model#ensureIndexes.

Виртуальные свойства

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

// define a schema
var personSchema = new Schema({
  name: {
    first: String,
    last: String
  }
});

// compile our model
var Person = mongoose.model('Person', personSchema);

// create a document
var axl = new Person({
  name: { first: 'Axl', last: 'Rose' }
});

Предположим, вы хотите вывести полное имя человека. Вы можете сделать это сами:

console.log(axl.name.first + ' ' + axl.name.last); // Axl Rose

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

personSchema.virtual('fullName').get(function () {
  return this.name.first + ' ' + this.name.last;
});

Теперь mongoose будет вызывать вашу функцию-геттер каждый раз, когда вы обращаетесь к свойству fullName:

console.log(axl.fullName); // Axl Rose

Если вы используете toJSON() или toObject() (или используете JSON.stringify() на документе mongoose), mongoose по умолчанию не будет включать виртуальные свойства. Передайте { virtuals: true } либо в toObject(), либо в toJSON().

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

personSchema.virtual('fullName').
  get(function() { return this.name.first + ' ' + this.name.last; }).
  set(function(v) {
    this.name.first = v.substr(0, v.indexOf(' '));
    this.name.last = v.substr(v.indexOf(' ') + 1);
  });
  
axl.fullName = 'William Rose'; // Now `axl.name.first` is "William"

Сеттеры виртуальных свойств применяются перед другими проверками. Таким образом, пример выше по-прежнему будет работать, даже если поля first и last имени были обязательными.

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

Псевдонимы

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

var personSchema = new Schema({
  n: {
    type: String,
    // Now accessing `name` will get you the value of `n`, and setting `n` will set the value of `name`
    alias: 'name'
  }
});

// Setting `name` will propagate to `n`
var person = new Person({ name: 'Val' });
console.log(person); // { n: 'Val' }
console.log(person.toObject({ virtuals: true })); // { n: 'Val', name: 'Val' }
console.log(person.name); // "Val"

person.name = 'Not Val';
console.log(person); // { n: 'Not Val' }

Параметры

Schema имеют несколько настраиваемых параметров, которые могут быть переданы в конструктор или set напрямую:

new Schema({..}, options);

// or

var schema = new Schema({..});
schema.set(option, value);

Допустимые параметры:

• autoIndex
• bufferCommands
• capped
• collection
• emitIndexErrors
• id
• [id](#id)
• minimize
• read
• safe
• shardKey
• strict
• toJSON
• toObject
• typeKey
• validateBeforeSave
• versionKey
• collation
• skipVersioning
• timestamps
• retainKeyOrder

Параметр: autoIndex

При запуске приложения Mongoose отправляет createIndex команду для каждого индекса, объявленного в вашей Schema. Начиная с Mongoose v3, индексы создаются в background по умолчанию. Если вы хотите отключить функцию автоматического создания и вручную управлять созданием индексов, установите параметр Schema вашей autoIndex в false и используйте метод ensureIndexes вашей модели.

var schema = new Schema({..}, { autoIndex: false });
var Clock = mongoose.model('Clock', schema);
Clock.ensureIndexes(callback);

Параметр: bufferCommands

По умолчанию mongoose буферизует команды, когда соединение прерывается, до тех пор, пока драйвер не сможет переподключиться. Чтобы отключить буферизацию, установите bufferCommands в false.

var schema = new Schema({..}, { bufferCommands: false });

Параметр: capped

Mongoose поддерживает коллекции capped MongoDB. Чтобы указать базовую коллекцию MongoDB как capped, установите параметр capped в максимальный размер коллекции в байтах.

new Schema({..}, { capped: 1024 });

Параметр capped также может быть установлен в объект, если вы хотите передать дополнительные параметры, такие как max или autoIndexId. В этом случае вы должны явно передать параметр size , который является обязательным.

new Schema({..}, { capped: { size: 1024, max: 1000, autoIndexId: true } });

Параметр: collection

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

var dataSchema = new Schema({..}, { collection: 'data' });

Параметр: emitIndexErrors

По умолчанию mongoose будет строить все указанные вами индексы в схеме, и выведет событие 'index' в модели, когда построение индекса завершится успешно или с ошибкой.

MyModel.on('index', function(error) {
  /* If error is truthy, index build failed */
});

Однако это затрудняет обнаружение ошибок при построении индексов. Параметр emitIndexErrors упрощает обнаружение ошибок при построении индекса. Если этот параметр включён, mongoose дополнительно выведет событие 'error' в модели, когда построение индекса завершится с ошибкой.

MyModel.schema.options.emitIndexErrors; // true
MyModel.on('error', function(error) {
  // gets an error whenever index build fails
});

Встроенный в Node.js испускатель событий выбрасывает исключение, если событие ошибки испускается, и нет слушателей, поэтому легко настроить приложение так, чтобы оно быстро завершалось при сбое построения индекса.

параметр: id

Mongoose по умолчанию назначает каждому из ваших схем виртуальный геттер id, который возвращает поле документа _id в формате строки, или, в случае ObjectIds, его шестнадцатеричную строку. Если вы не хотите, чтобы геттер id добавлялся в вашу схему, вы можете отключить его, передав этот параметр во время создания схемы.

// default behavior
var schema = new Schema({ name: String });
var Page = mongoose.model('Page', schema);
var p = new Page({ name: 'mongodb.org' });
console.log(p.id); // '50341373e894ad16347efe01'

// disabled id
var schema = new Schema({ name: String }, { id: false });
var Page = mongoose.model('Page', schema);
var p = new Page({ name: 'mongodb.org' });
console.log(p.id); // undefined

параметр: _id

Mongoose по умолчанию назначает каждой вашей схеме поле _id, если оно не передано в конструктор Schema. Присвоенный тип — ObjectId, чтобы соответствовать поведению по умолчанию MongoDB. Если вы вообще не хотите, чтобы _id добавлялся в вашу схему, вы можете отключить его с помощью этого параметра.

Вы можете только использовать этот параметр для поддокументов. Mongoose не может сохранить документ без знания его id, поэтому вы получите ошибку, если попытаетесь сохранить документ без _id.

// default behavior
var schema = new Schema({ name: String });
var Page = mongoose.model('Page', schema);
var p = new Page({ name: 'mongodb.org' });
console.log(p); // { _id: '50341373e894ad16347efe01', name: 'mongodb.org' }

// disabled _id
var childSchema = new Schema({ name: String }, { _id: false });
var parentSchema = new Schema({ children: [childSchema] });

var Model = mongoose.model('Model', parentSchema);

Model.create({ children: [{ name: 'Luke' }] }, function(error, doc) {
  // doc.children[0]._id will be undefined
});

параметр: minimize

Mongoose по умолчанию «минимизирует» схемы, удаляя пустые объекты.

var schema = new Schema({ name: String, inventory: {} });
var Character = mongoose.model('Character', schema);

// will store `inventory` field if it is not empty
var frodo = new Character({ name: 'Frodo', inventory: { ringOfPower: 1 }});
Character.findOne({ name: 'Frodo' }, function(err, character) {
  console.log(character); // { name: 'Frodo', inventory: { ringOfPower: 1 }}
});

// will not store `inventory` field if it is empty
var sam = new Character({ name: 'Sam', inventory: {}});
Character.findOne({ name: 'Sam' }, function(err, character) {
  console.log(character); // { name: 'Sam' }
});

Это поведение можно переопределить, установив параметр minimize в false. В этом случае будут храниться пустые объекты.

var schema = new Schema({ name: String, inventory: {} }, { minimize: false });
var Character = mongoose.model('Character', schema);

// will store `inventory` if empty
var sam = new Character({ name: 'Sam', inventory: {}});
Character.findOne({ name: 'Sam' }, function(err, character) {
  console.log(character); // { name: 'Sam', inventory: {}}
});

параметр: read

Позволяет установить параметры query#read на уровне схемы, предоставляя способ применения параметров ReadPreferences по умолчанию ко всем запросам, полученным от модели.

var schema = new Schema({..}, { read: 'primary' });            // also aliased as 'p'
var schema = new Schema({..}, { read: 'primaryPreferred' });   // aliased as 'pp'
var schema = new Schema({..}, { read: 'secondary' });          // aliased as 's'
var schema = new Schema({..}, { read: 'secondaryPreferred' }); // aliased as 'sp'
var schema = new Schema({..}, { read: 'nearest' });            // aliased as 'n'

Также разрешены псевдонимы каждого параметра, поэтому вместо того, чтобы писать «secondaryPreferred» и ошибаться в написании, можно просто передать «sp».

Параметр read также позволяет указать *наборы тегов*. Они сообщают драйверу, с какими членами реплики-набора он должен пытаться читать. Дополнительную информацию о наборах тегов можно найти здесь и здесь.

ПРИМЕЧАНИЕ: при подключении можно также указать параметр стратегии чтения драйвера strategy:

// pings the replset members periodically to track network latency
var options = { replset: { strategy: 'ping' }};
mongoose.connect(uri, options);

var schema = new Schema({..}, { read: ['nearest', { disk: 'ssd' }] });
mongoose.model('JellyBean', schema);

параметр: safe

Этот параметр передаётся в MongoDB со всеми операциями и определяет, должны ли ошибки возвращаться в наши колбэки, а также настраивает поведение при записи.

var safe = true;
new Schema({ .. }, { safe: safe });

По умолчанию это установлено в значение true для всех схем, гарантируя, что любая возникающая ошибка передаётся обратно в наш колбэк. Установив safe на другое значение, например, { j: 1, w: 2, wtimeout: 10000 }, мы можем гарантировать, что запись была внесена в журнал MongoDB (j: 1), по крайней мере, на 2 реплики (w: 2) и что запись будет ограничена по времени, если это займёт более 10 секунд (wtimeout: 10000). Ошибки по-прежнему будут передаваться в наш колбэк.

ПРИМЕЧАНИЕ: В 3.6.x также необходимо отключить версионирование. В 3.7.x и более поздних версиях версионирование автоматически отключится, когда safe будет установлено в значение false

**ПРИМЕЧАНИЕ: данная настройка переопределяет любые настройки, заданные при передаче параметров базы данных при создании подключения.

Существуют и другие проблемы с учётом записей, такие как { w: "majority" }. Подробнее см. в документации MongoDB здесь.

var safe = { w: "majority", wtimeout: 10000 };
new Schema({ .. }, { safe: safe });

параметр: shardKey

Параметр shardKey используется при фрагментированной архитектуре MongoDB. Каждому фрагментированному набору данных присваивается ключ фрагментации, который должен присутствовать во всех операциях вставки/обновления. Нам нужно просто установить этот параметр схемы на тот же ключ фрагментации, и всё будет готово.

new Schema({ .. }, { shardKey: { tag: 1, name: 1 }})

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

параметр: strict

Параметр strict (включён по умолчанию) гарантирует, что значения, переданные в наш конструктор модели, которые не были указаны в нашей схеме, не будут сохранены в базе данных.

var thingSchema = new Schema({..})
var Thing = mongoose.model('Thing', thingSchema);
var thing = new Thing({ iAmNotInTheSchema: true });
thing.save(); // iAmNotInTheSchema is not saved to the db

// set to false..
var thingSchema = new Schema({..}, { strict: false });
var thing = new Thing({ iAmNotInTheSchema: true });
thing.save(); // iAmNotInTheSchema is now saved to the db!!

Это также влияет на использование doc.set() для установки значения свойства.

var thingSchema = new Schema({..})
var Thing = mongoose.model('Thing', thingSchema);
var thing = new Thing;
thing.set('iAmNotInTheSchema', true);
thing.save(); // iAmNotInTheSchema is not saved to the db

Это значение можно переопределить на уровне экземпляра модели, передав второй булевый аргумент:

var Thing = mongoose.model('Thing');
var thing = new Thing(doc, true);  // enables strict mode
var thing = new Thing(doc, false); // disables strict mode

Параметр strict также можно установить в значение "throw", что приведёт к возникновению ошибок вместо удаления плохих данных.

ПРИМЕЧАНИЕ: не устанавливайте значение false, если у вас нет веских оснований.

ПРИМЕЧАНИЕ: в mongoose v2 значение по умолчанию было false.

ПРИМЕЧАНИЕ: любые пары ключ/значение, заданные на экземпляре, которые не существуют в вашей схеме, всегда игнорируются, независимо от параметров схемы.

var thingSchema = new Schema({..})
var Thing = mongoose.model('Thing', thingSchema);
var thing = new Thing;
thing.iAmNotInTheSchema = true;
thing.save(); // iAmNotInTheSchema is never saved to the db

параметр: toJSON

Абсолютно идентичен параметру toObject, но применяется только при вызове метода документов toJSON.

var schema = new Schema({ name: String });
schema.path('name').get(function (v) {
  return v + ' is my name';
});
schema.set('toJSON', { getters: true, virtuals: false });
var M = mongoose.model('Person', schema);
var m = new M({ name: 'Max Headroom' });
console.log(m.toObject()); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom' }
console.log(m.toJSON()); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom is my name' }
// since we know toJSON is called whenever a js object is stringified:
console.log(JSON.stringify(m)); // { "_id": "504e0cd7dd992d9be2f20b6f", "name": "Max Headroom is my name" }

Чтобы увидеть все доступные toJSON/toObject параметры, прочитайте это.

параметр: toObject

У документов есть метод toObject, который преобразует документ mongoose в обычный объект JavaScript. Этот метод принимает несколько параметров. Вместо того, чтобы применять эти параметры к каждому документу по отдельности, мы можем объявить их здесь и применять к документам этой схемы по умолчанию.

Чтобы все виртуальные поля отображались в выводе console.log, установите параметр toObject в значение { getters: true }:

var schema = new Schema({ name: String });
schema.path('name').get(function (v) {
  return v + ' is my name';
});
schema.set('toObject', { getters: true });
var M = mongoose.model('Person', schema);
var m = new M({ name: 'Max Headroom' });
console.log(m); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom is my name' }

Чтобы увидеть все доступные toObject параметры, прочитайте это.

параметр: typeKey

По умолчанию, если у вас есть объект с ключом «type» в вашей схеме, mongoose интерпретирует его как объявление типа.

// Mongoose interprets this as 'loc is a String'
var schema = new Schema({ loc: { type: String, coordinates: [Number] } });

Однако для приложений, таких как geoJSON, свойство «type» важно. Если вы хотите контролировать, какой ключ использует mongoose для поиска объявлений типов, установите параметр схемы «typeKey».

var schema = new Schema({
  // Mongoose interpets this as 'loc is an object with 2 keys, type and coordinates'
  loc: { type: String, coordinates: [Number] },
  // Mongoose interprets this as 'name is a String'
  name: { $type: String }
}, { typeKey: '$type' }); // A '$type' key means this object is a type declaration

параметр: validateBeforeSave

По умолчанию документы автоматически проверяются перед сохранением в базе данных. Это делается для предотвращения сохранения невалидного документа. Если вы хотите вручную обрабатывать проверку и сможете сохранять объекты, не прошедшие проверку, вы можете установить validateBeforeSave в false.

var schema = new Schema({ name: String });
schema.set('validateBeforeSave', false);
schema.path('name').validate(function (value) {
    return v != null;
});
var M = mongoose.model('Person', schema);
var m = new M({ name: null });
m.validate(function(err) {
    console.log(err); // Will tell you that null is not allowed.
});
m.save(); // Succeeds despite being invalid

параметр: versionKey

Ключ versionKey устанавливается на каждый документ при его первом создании Mongoose. Значение этого ключа содержит внутреннюю ревизию документа. Параметр versionKey — это строка, представляющая путь, используемый для версионирования. По умолчанию это __v. Если это конфликтует с вашим приложением, вы можете настроить его:

var schema = new Schema({ name: 'string' });
var Thing = mongoose.model('Thing', schema);
var thing = new Thing({ name: 'mongoose v3' });
thing.save(); // { __v: 0, name: 'mongoose v3' }

// customized versionKey
new Schema({..}, { versionKey: '_somethingElse' })
var Thing = mongoose.model('Thing', schema);
var thing = new Thing({ name: 'mongoose v3' });
thing.save(); // { _somethingElse: 0, name: 'mongoose v3' }

Версионирование документов также можно отключить, установив versionKey в значение false. НЕ отключайте версионирование, если вы не уверены в своих действиях.

new Schema({..}, { versionKey: false });
var Thing = mongoose.model('Thing', schema);
var thing = new Thing({ name: 'no versioning please' });
thing.save(); // { name: 'no versioning please' }

параметр: collation

Устанавливает значение по умолчанию для collations для каждого запроса и агрегации. Вот краткий обзор collations для начинающих.

var schema = new Schema({
  name: String
}, { collation: { locale: 'en_US', strength: 1 } });

var MyModel = db.model('MyModel', schema);

MyModel.create([{ name: 'val' }, { name: 'Val' }]).
  then(function() {
    return MyModel.find({ name: 'val' });
  }).
  then(function(docs) {
    // `docs` will contain both docs, because `strength: 1` means
    // MongoDB will ignore case when matching.
  });
  

параметр: skipVersioning

skipVersioning позволяет исключить пути из версионирования (т. е. внутренняя ревизия не будет увеличиваться, даже если эти пути обновлены). Не делайте этого, если не уверены в своих действиях. Для поддокументов включите это в родительский документ, используя полное квалифицированное имя пути.

new Schema({..}, { skipVersioning: { dontVersionMe: true } });
thing.dontVersionMe.push('hey');
thing.save(); // version is not incremented

параметр: timestamps

Если установлено timestamps, Mongoose назначает поля createdAt и updatedAt вашей схеме, присвоенный тип — Date.

По умолчанию имена двух полей — createdAt и updatedAt, настраивать имена полей можно, установив timestamps.createdAt и timestamps.updatedAt.

var thingSchema = new Schema({..}, { timestamps: { createdAt: 'created_at' } });
var Thing = mongoose.model('Thing', thingSchema);
var thing = new Thing();
thing.save(); // `created_at` & `updatedAt` will be included

параметр: useNestedStrict

В mongoose 4, update() и findOneAndUpdate() проверяют только настройку strict верхнего уровня схемы.

var childSchema = new Schema({}, { strict: false });
var parentSchema = new Schema({ child: childSchema }, { strict: 'throw' });
var Parent = mongoose.model('Parent', parentSchema);
Parent.update({}, { 'child.name': 'Luke Skywalker' }, function(error) {
  // Error because parentSchema has `strict: throw`, even though
  // `childSchema` has `strict: false`
});

var update = { 'child.name': 'Luke Skywalker' };
var opts = { strict: false };
Parent.update({}, update, opts, function(error) {
  // This works because passing `strict: false` to `update()` overwrites
  // the parent schema.
});

Если вы установите useNestedStrict в значение true, mongoose будет использовать параметр strict дочерней схемы для преобразования обновлений.

var childSchema = new Schema({}, { strict: false });
var parentSchema = new Schema({ child: childSchema },
  { strict: 'throw', useNestedStrict: true });
var Parent = mongoose.model('Parent', parentSchema);
Parent.update({}, { 'child.name': 'Luke Skywalker' }, function(error) {
  // Works!
});

параметр: retainKeyOrder

По умолчанию mongoose изменяет порядок ключей в документах как оптимизацию производительности. Например, new Model({ first: 1, second: 2 }); фактически хранится в MongoDB как { second: 2, first: 1 }. Это поведение считается устаревшим, так как оно имеет много непреднамеренных побочных эффектов, включая затруднение обработки документов, чьё поле _id является объектом.

Mongoose >= 4.6.4 имеет параметр retainKeyOrder для схем, который гарантирует, что mongoose всегда будет сохранять правильный порядок ключей объекта.

var testSchema = new Schema({ first: Number, second: Number }, { retainKeyOrder: true });
var Test = mongoose.model('Test', testSchema);
Test.create({ first: 1, second: 2 }); // Will be stored in mongodb as `{ first: 1, second: 2 }`

Подключаемые модули

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

Далее

Теперь, когда мы рассмотрели Schemas, давайте рассмотрим SchemaTypes.