スキーマ

スキーマコンストラクタ。

例

const child = new Schema({ name: String });
const schema = new Schema({ name: String, age: Number, children: [child] });
const Tree = mongoose.model('Tree', schema);

// setting schema options
new Schema({ name: String }, { id: false, autoIndex: false })

オプション

• autoIndex: 真偽値 - デフォルトはnull（接続のautoIndexオプションを使用することを意味します）
• autoCreate: 真偽値 - デフォルトはnull（接続のautoCreateオプションを使用することを意味します）
• bufferCommands: 真偽値 - デフォルトはtrue
• bufferTimeoutMS: 数値 - デフォルトは10000（10秒）。 bufferCommandsが有効な場合、Mongooseがエラーを発生させる前に接続の再確立を待機する時間。
• capped: 真偽値 | 数値 | オブジェクト - デフォルトはfalse
• collection: 文字列 - デフォルトなし
• discriminatorKey: 文字列 - デフォルトは__t
• id: 真偽値 - デフォルトはtrue
• _id: 真偽値 - デフォルトはtrue
• minimize: 真偽値 - 手動で呼び出されたときのdocument#toObjectの動作を制御します - デフォルトはtrue
• read: 文字列
• readConcern: オブジェクト - デフォルトはnull、すべてのクエリにデフォルトの読み取りコンサーンを設定するために使用します。
• writeConcern: オブジェクト - デフォルトはnull、MongoDBサーバーのデフォルトの書き込みコンサーン設定をオーバーライドするために使用します
• shardKey: オブジェクト - デフォルトはnull
• strict: 真偽値 - デフォルトはtrue
• strictQuery: 真偽値 - デフォルトはfalse
• toJSON - オブジェクト - デフォルトなし
• toObject - オブジェクト - デフォルトなし
• typeKey - 文字列 - デフォルトは 'type'
• validateBeforeSave - 真偽値 - デフォルトはtrue
• validateModifiedOnly - 真偽値 - デフォルトはfalse
• versionKey: 文字列またはオブジェクト - デフォルトは"__v"
• optimisticConcurrency: 真偽値 - デフォルトはfalse。楽観的同時実行制御を有効にするにはtrueに設定します。
• collation: オブジェクト - デフォルトはnull（照合を使用しないことを意味します）
• timeseries: オブジェクト - デフォルトはnull（このスキーマのコレクションは時系列コレクションではないことを意味します）
• selectPopulatedPaths: 真偽値 - デフォルトはtrue
• skipVersioning: オブジェクト - バージョニングから除外するパス
• timestamps: オブジェクトまたは真偽値 - デフォルトはfalse。 trueの場合、MongooseはスキーマにcreatedAtおよびupdatedAtプロパティを追加し、それらのプロパティを管理します。
• pluginTags: 文字列の配列 - デフォルトはundefined。設定されていて、プラグインがtagsオプションで呼び出された場合、一致するタグを持つスキーマにのみそのプラグインを適用します。
• virtuals: オブジェクト - 定義する仮想、.virtualのエイリアス
• [collectionOptions]: Model.createCollection()を呼び出すか、autoCreateをtrueに設定したときにcreateCollection()に渡されるオプションを持つオブジェクト。

ネストされたスキーマのオプション

• excludeIndexes: 真偽値 - デフォルトはfalse。 trueの場合、このスキーマのパスにインデックスを作成しません。

注意

スキーマをネストする場合（上記の例ではchildren）、常に子スキーマを親に渡す前に宣言してください。

さまざまな組み込みMongooseスキーマタイプ。

例

const mongoose = require('mongoose');
const ObjectId = mongoose.Schema.Types.ObjectId;

タイプ

• 文字列
• 数値
• 真偽値 | Bool
• 配列
• Buffer
• 日付
• ObjectId | Oid
• Mixed
• UUID
• BigInt

この公開されている`Mixed` SchemaTypeへのアクセスを使用して、スキーマで使用できます。

const Mixed = mongoose.Schema.Types.Mixed;
new mongoose.Schema({ _user: Mixed })

許可されるインデックスタイプ

キパス/スキーマタイプのペアをこのスキーマに追加します。

例

const ToySchema = new Schema();
ToySchema.add({ name: 'string', color: 'string', price: 'number' });

const TurboManSchema = new Schema();
// You can also `add()` another schema and copy over all paths, virtuals,
// getters, setters, indexes, methods, and statics.
TurboManSchema.add(ToySchema).add({ year: Number });

pathのエイリアスを追加します。これは、`alias`を取得または設定することが、`path`を取得または設定することと同等であることを意味します。

例

const toySchema = new Schema({ n: String });

// Make 'name' an alias for 'n'
toySchema.alias('n', 'name');

const Toy = mongoose.model('Toy', toySchema);
const turboMan = new Toy({ n: 'Turbo Man' });

turboMan.name; // 'Turbo Man'
turboMan.n; // 'Turbo Man'

turboMan.name = 'Turbo Man Action Figure';
turboMan.n; // 'Turbo Man Action Figure'

await turboMan.save(); // Saves { _id: ..., n: 'Turbo Man Action Figure' }

子スキーマ（ドキュメント配列と単一のネストされたサブドキュメントから）と対応するコンパイル済みモデルの配列。配列の各要素は、`schema`と`model`の2つのプロパティを持つオブジェクトです。

このプロパティは、通常、プラグインの作成者と上級ユーザーにのみ役立ちます。mongooseを使用するために、このプロパティと対話する必要はまったくありません。

このスキーマからすべてのインデックスを削除します。

clearIndexesは、スキーマオブジェクトからインデックスのみを削除します。 MongoDBのインデックスには**影響しません**。

例

const ToySchema = new Schema({ name: String, color: String, price: Number });
ToySchema.index({ name: 1 });
ToySchema.index({ color: 1 });

// Remove all indexes on this schema
ToySchema.clearIndexes();

ToySchema.indexes(); // []

スキーマのディープコピーを返します

例

const schema = new Schema({ name: String });
const clone = schema.clone();
clone === schema; // false
clone.path('name'); // SchemaString { ... }

既存のスキーマにディスクリミネータを適用することにより、スキーマを継承します。

例

const eventSchema = new mongoose.Schema({ timestamp: Date }, { discriminatorKey: 'kind' });

const clickedEventSchema = new mongoose.Schema({ element: String }, { discriminatorKey: 'kind' });
const ClickedModel = eventSchema.discriminator('clicked', clickedEventSchema);

const Event = mongoose.model('Event', eventSchema);

Event.discriminators['clicked']; // Model { clicked }

const doc = await Event.create({ kind: 'clicked', element: '#hero' });
doc.element; // '#hero'
doc instanceof ClickedModel; // true

Array＃forEachと同様にスキーマパスを反復処理します。

コールバックには、パス名とschemaTypeインスタンスが渡されます。

例

const userSchema = new Schema({ name: String, registeredAt: Date });
userSchema.eachPath((pathname, schematype) => {
  // Prints twice:
  // name SchemaString { ... }
  // registeredAt SchemaDate { ... }
  console.log(pathname, schematype);
});

スキーマオプションを取得します。

例

schema.get('strict'); // true
schema.set('strict', false);
schema.get('strict'); // false

このスキーマのインデックス（ほとんどの場合複合）を定義します。

例

schema.index({ first: 1, last: -1 })

このスキーマが`schema.index（）`を介して、またはパスのオプションで`index：true`によって宣言するインデックスのリストを返します。インデックスは配列`[spec、options]`として表されます。

例

const userSchema = new Schema({
  email: { type: String, required: true, unique: true },
  registeredAt: { type: Date, index: true }
});

// [ [ { email: 1 }, { unique: true, background: true } ],
//   [ { registeredAt: 1 }, { background: true } ] ]
userSchema.indexes();

プラグインはこの関数の戻り値を使用してスキーマのインデックスを変更できます。たとえば、以下のプラグインは、デフォルトですべてのインデックスを一意にします。

function myPlugin(schema) {
  for (const index of schema.indexes()) {
    if (index[1].unique === undefined) {
      index[1].unique = true;
    }
  }
}

ES6クラスをスキーマにロードします。 セッター + ゲッター、静的メソッド、およびインスタンスメソッドをスキーマ仮想、静的、およびメソッドにマップします。

例

const md5 = require('md5');
const userSchema = new Schema({ email: String });
class UserClass {
  // `gravatarImage` becomes a virtual
  get gravatarImage() {
    const hash = md5(this.email.toLowerCase());
    return `https://www.gravatar.com/avatar/${hash}`;
  }

  // `getProfileUrl()` becomes a document method
  getProfileUrl() {
    return `https://mysite.com/${this.email}`;
  }

  // `findByEmail()` becomes a static
  static findByEmail(email) {
    return this.findOne({ email });
  }
}

// `schema` will now have a `gravatarImage` virtual, a `getProfileUrl()` method,
// and a `findByEmail()` static
userSchema.loadClass(UserClass);

このスキーマからコンパイルされたモデルから構築されたドキュメントにインスタンスメソッドを追加します。

例

const schema = kittySchema = new Schema(..);

schema.method('meow', function () {
  console.log('meeeeeoooooooooooow');
})

const Kitty = mongoose.model('Kitty', schema);

const fizz = new Kitty;
fizz.meow(); // meeeeeooooooooooooow

名前/関数ペアのハッシュが唯一の引数として渡された場合、各名前/関数ペアはメソッドとして追加されます。

schema.method({
    purr: function () {}
  , scratch: function () {}
});

// later
const fizz = new Kitty;
fizz.purr();
fizz.scratch();

注: Schema.method() はインスタンスメソッドを Schema.methods オブジェクトに追加します。 ガイド に示されているように、インスタンスメソッドを Schema.methods オブジェクトに直接追加することもできます。

スキーマコンストラクタに渡された元のオブジェクト

例

const schema = new Schema({ a: String }).add({ b: String });
schema.obj; // { a: String }

元のスキーマから省略されたパスを除いたパスを持つ新しいスキーマを返します。

このメソッドは、Mongoose スキーマのための Lodash の omit() 関数 に類似しています。

例

const schema = Schema({ name: String, age: Number });
// Creates a new schema omitting the `age` path
const newSchema = schema.omit(['age']);

newSchema.path('name'); // SchemaString { ... }
newSchema.path('age'); // undefined

スキーマパスを取得/設定します。

パスを設定します (アリティが 2 の場合)。パスを取得します (アリティが 1 の場合)。

例

schema.path('name') // returns a SchemaType
schema.path('name', Number) // changes the schemaType of `name` to Number

このスキーマの path の pathType を返します。

パスが与えられた場合、それが実際のパス、仮想パス、ネストされたパス、またはアドホック/未定義のパスであるかどうかを返します。

例

const s = new Schema({ name: String, nested: { foo: String } });
s.virtual('foo').get(() => 42);
s.pathType('name'); // "real"
s.pathType('nested'); // "nested"
s.pathType('foo'); // "virtual"
s.pathType('fail'); // "adhocOrUndefined"

このスキーマで定義されたパス。キーはこのスキーマのトップレベルパスであり、値は SchemaType クラスのインスタンスです。

例

const schema = new Schema({ name: String }, { _id: false });
schema.paths; // { name: SchemaString { ... } }

schema.add({ age: Number });
schema.paths; // { name: SchemaString { ... }, age: SchemaNumber { ... } }

このスキーマから選択された paths を持つ新しいスキーマを返します。

このメソッドは、Mongoose スキーマのための Lodash の pick() 関数 に類似しています。

例

const schema = Schema({ name: String, age: Number });
// Creates a new schema with the same `name` path as `schema`,
// but no `age` path.
const newSchema = schema.pick(['name']);

newSchema.path('name'); // SchemaString { ... }
newSchema.path('age'); // undefined

このスキーマのプラグインを登録します。

例

const s = new Schema({ name: String });
s.plugin(schema => console.log(schema.path('name').path));
mongoose.model('Test', s); // Prints 'name'

または、オプション付きで

const s = new Schema({ name: String });
s.plugin((schema, opts) => console.log(opts.text, schema.path('name').path), { text: "Schema Path Name:" });
mongoose.model('Test', s); // Prints 'Schema Path Name: name'

ドキュメントのポストフックを定義します。

const schema = new Schema(..);
schema.post('save', function (doc) {
  console.log('this fired after a document was saved');
});

schema.post('find', function(docs) {
  console.log('this fired after you ran a find query');
});

schema.post(/Many$/, function(res) {
  console.log('this fired after you ran `updateMany()` or `deleteMany()`');
});

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

const m = new Model(..);
m.save(function(err) {
  console.log('this fires after the `post` hook');
});

m.find(function(err, docs) {
  console.log('this fires after the post find hook');
});

モデルのプリフックを定義します。

例

const toySchema = new Schema({ name: String, created: Date });

toySchema.pre('save', function(next) {
  if (!this.created) this.created = new Date;
  next();
});

toySchema.pre('validate', function(next) {
  if (this.name !== 'Woody') this.name = 'Woody';
  next();
});

// Equivalent to calling `pre()` on `find`, `findOne`, `findOneAndUpdate`.
toySchema.pre(/^find/, function(next) {
  console.log(this.getFilter());
});

// Equivalent to calling `pre()` on `updateOne`, `findOneAndUpdate`.
toySchema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
  console.log(this.getFilter());
});

toySchema.pre('deleteOne', function() {
  // Runs when you call `Toy.deleteOne()`
});

toySchema.pre('deleteOne', { document: true }, function() {
  // Runs when you call `doc.deleteOne()`
});

メソッド呼び出しをキューに追加します。

例

schema.methods.print = function() { console.log(this); };
schema.queue('print', []); // Print the doc every one is instantiated

const Model = mongoose.model('Test', schema);
new Model({ name: 'test' }); // Prints '{"_id": ..., "name": "test" }'

指定された path (または [paths]) を削除します。

例

const schema = new Schema({ name: String, age: Number });
schema.remove('name');
schema.path('name'); // Undefined
schema.path('age'); // SchemaNumber { ... }

または、配列として

schema.remove(['name', 'age']);
schema.path('name'); // Undefined
schema.path('age'); // Undefined

名前またはインデックス仕様でインデックスを削除します。

removeIndex はスキーマオブジェクトからインデックスのみを削除します。MongoDB のインデックスには**影響しません**。

例

const ToySchema = new Schema({ name: String, color: String, price: Number });

// Add a new index on { name, color }
ToySchema.index({ name: 1, color: 1 });

// Remove index on { name, color }
// Keep in mind that order matters! `removeIndex({ color: 1, name: 1 })` won't remove the index
ToySchema.removeIndex({ name: 1, color: 1 });

// Add an index with a custom name
ToySchema.index({ color: 1 }, { name: 'my custom index name' });
// Remove index by name
ToySchema.removeIndex('my custom index name');

指定された仮想パスをスキーマから削除します。

このスキーマで必須のパス文字列の配列を返します。

例

const s = new Schema({
  name: { type: String, required: true },
  age: { type: String, required: true },
  notes: String
});
s.requiredPaths(); // [ 'age', 'name' ]

Mongoose が Model.createSearchIndex() を使用して作成する Atlas 検索インデックス を追加します。この関数は、MongoDB Atlas に接続されている場合にのみ機能します。

例

const ToySchema = new Schema({ name: String, color: String, price: Number });
ToySchema.searchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });

スキーマオプションを設定します。

例

schema.set('strict'); // 'true' by default
schema.set('strict', false); // Sets 'strict' to false
schema.set('strict'); // 'false'

このスキーマからコンパイルされたモデルに静的「クラス」メソッドを追加します。

例

const schema = new Schema(..);
// Equivalent to `schema.statics.findByName = function(name) {}`;
schema.static('findByName', function(name) {
  return this.find({ name: name });
});

const Drink = mongoose.model('Drink', schema);
await Drink.findByName('LaCroix');

名前/関数ペアのハッシュが唯一の引数として渡された場合、各名前/関数ペアはメソッドとして追加されます。

schema.static({
    findByName: function () {..}
  , findByCost: function () {..}
});

const Drink = mongoose.model('Drink', schema);
await Drink.findByName('LaCroix');
await Drink.findByCost(3);

名前/関数ペアのハッシュが唯一の引数として渡された場合、各名前/関数ペアはスタティックとして追加されます。

指定された名前で仮想タイプを作成します。

指定された name の仮想タイプを返します。

このスキーマで定義されているすべての仮想を含むオブジェクト。オブジェクトのキーは仮想パスであり、値は VirtualType のインスタンスです。

このプロパティは、通常、プラグインの作成者と上級ユーザーにのみ役立ちます。mongooseを使用するために、このプロパティと対話する必要はまったくありません。

例

const schema = new Schema({});
schema.virtual('answer').get(() => 42);

console.log(schema.virtuals); // { answer: VirtualType { path: 'answer', ... } }
console.log(schema.virtuals['answer'].getters[0].call()); // 42

予約済みドキュメントキー。

このオブジェクトのキーは、Mongoose/Mongoose プラグインの機能を損なう可能性があるため、スキーマ宣言で警告される名前です。これらのプロパティ名のいずれかを使用して new Schema() でスキーマを作成すると、Mongoose は警告をログに記録します。

• _posts
• _pres
• collection
• emit
• errors
• get
• init
• isModified
• isNew
• listeners
• modelName
• on
• once
• populated
• prototype
• remove
• removeListener
• save
• schema
• toObject
• validate

注: これらの用語をメソッド名として使用することは許可されていますが、既存の Mongoose ドキュメントメソッドを踏みつける可能性があるため、自己責任で使用してください。

 const schema = new Schema(..);
 schema.methods.init = function () {} // potentially breaking