Mongoose Documentation

Guides

• Add Your Own
• Alternate Property Names
• Automatic type inference
• Available as part of the Tidelift Subscription
• Built-in Promises
• Built-in Validators
• Compiling your first model
• Congratulations
• Connection Helper
• Creating Your First Document
• Creating a Basic Custom Schema Type
• Creating from ES6 Classes Using loadClass()
• Declaring Defaults in Your Schema
• Defining your schema
• Documents vs Models
• Example
• Executing
• Getters
• Getting Started
• Getting Started with Transactions
• Iterating using next()
• Manually Typed Query Helpers
• Methods
• Mongoose 7
• Mongoose Core Concepts
• Mongoose Jobs
• Operation Buffering
• Point Schema
• Put Mongoose as a Peer Dependency
• Recommended testEnvironment
• Removed rawResult option for findOneAndUpdate()
• Saving refs
• Setting Up Field Level Encryption with Mongoose
• Subdocument Arrays
• Summary
• TLS/SSL Validation
• The model.discriminator() function
• The strictQuery Option
• TypeError: Cannot read properties of undefined (reading 'prototype')
• Types of Middleware
• Using Lean
• Using PopulatedDoc
• Using npm list
• Using the Browser Library
• Validators
• Version Requirements
• Version Requirements
• Video Courses
• What is a SchemaType?
• What is a Subdocument?
• Your First Virtual
• cloneDeep()
• findOneAndUpdate() new field is now false by default
• strictQuery

Methods

• Aggregate()
• Aggregate.prototype.addFields()
• Aggregate.prototype.allowDiskUse()
• Aggregate.prototype.append()
• Aggregate.prototype.catch()
• Aggregate.prototype.collation()
• Aggregate.prototype.count()
• Aggregate.prototype.cursor()
• Aggregate.prototype.densify()
• Aggregate.prototype.exec()
• Aggregate.prototype.explain()
• Aggregate.prototype.facet()
• Aggregate.prototype.fill()
• Aggregate.prototype.finally()
• Aggregate.prototype.graphLookup()
• Aggregate.prototype.group()
• Aggregate.prototype.hint()
• Aggregate.prototype.limit()
• Aggregate.prototype.lookup()
• Aggregate.prototype.match()
• Aggregate.prototype.model()
• Aggregate.prototype.near()
• Aggregate.prototype.option()
• Aggregate.prototype.options
• Aggregate.prototype.pipeline()
• Aggregate.prototype.project()
• Aggregate.prototype.read()
• Aggregate.prototype.readConcern()
• Aggregate.prototype.redact()
• Aggregate.prototype.replaceRoot()
• Aggregate.prototype.sample()
• Aggregate.prototype.search()
• Aggregate.prototype.session()
• Aggregate.prototype.skip()
• Aggregate.prototype.sort()
• Aggregate.prototype.sortByCount()
• Aggregate.prototype.then()
• Aggregate.prototype.unionWith()
• Aggregate.prototype.unwind()
• Aggregate.prototype[Symbol.asyncIterator]()
• AggregationCursor()
• AggregationCursor.prototype.addCursorFlag()
• AggregationCursor.prototype.close()
• AggregationCursor.prototype.eachAsync()
• AggregationCursor.prototype.map()
• AggregationCursor.prototype.next()
• AggregationCursor.prototype[Symbol.asyncIterator]()
• ArraySubdocument.prototype.$parent()
• ArraySubdocument.prototype.parentArray()
• Connection()
• Connection.prototype.aggregate()
• Connection.prototype.asPromise()
• Connection.prototype.bulkWrite()
• 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.listCollections()
• Connection.prototype.listDatabases()
• Connection.prototype.model()
• Connection.prototype.modelNames()
• Connection.prototype.models
• Connection.prototype.name
• Connection.prototype.on()
• Connection.prototype.once()
• 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.prototype.withSession()
• Decimal128()
• Document.prototype.$assertPopulated()
• Document.prototype.$clearModifiedPaths()
• Document.prototype.$clone()
• Document.prototype.$createModifiedPathsSnapshot()
• Document.prototype.$errors
• Document.prototype.$getAllSubdocs()
• Document.prototype.$getPopulatedDocs()
• Document.prototype.$ignore()
• Document.prototype.$inc()
• Document.prototype.$init()
• Document.prototype.$isDefault()
• Document.prototype.$isDeleted()
• Document.prototype.$isEmpty()
• Document.prototype.$isModified()
• Document.prototype.$isNew
• Document.prototype.$locals
• Document.prototype.$markValid()
• Document.prototype.$op
• Document.prototype.$parent()
• Document.prototype.$populated()
• Document.prototype.$restoreModifiedPathsSnapshot()
• Document.prototype.$session()
• Document.prototype.$set()
• Document.prototype.$timestamps()
• Document.prototype.$validate()
• Document.prototype.$where
• Document.prototype.depopulate()
• Document.prototype.directModifiedPaths()
• Document.prototype.equals()
• Document.prototype.errors
• Document.prototype.get()
• Document.prototype.getChanges()
• Document.prototype.id
• Document.prototype.init()
• Document.prototype.inspect()
• Document.prototype.invalidate()
• Document.prototype.isDirectModified()
• Document.prototype.isDirectSelected()
• Document.prototype.isInit()
• Document.prototype.isModified()
• Document.prototype.isNew
• Document.prototype.isSelected()
• Document.prototype.markModified()
• Document.prototype.modifiedPaths()
• Document.prototype.overwrite()
• Document.prototype.parent()
• Document.prototype.populate()
• Document.prototype.populated()
• Document.prototype.replaceOne()
• Document.prototype.save()
• Document.prototype.schema
• Document.prototype.set()
• Document.prototype.toJSON()
• Document.prototype.toObject()
• Document.prototype.toString()
• Document.prototype.unmarkModified()
• Document.prototype.updateOne()
• Document.prototype.validate()
• Document.prototype.validateSync()
• Error()
• Error.CastError
• Error.DivergentArrayError
• Error.DocumentNotFoundError
• Error.MissingSchemaError
• Error.MongooseServerSelectionError
• Error.OverwriteModelError
• Error.ParallelSaveError
• Error.StrictModeError
• Error.StrictPopulateError
• Error.ValidationError
• Error.ValidatorError
• Error.VersionError
• Error.messages
• Error.prototype.name
• Example:
• Model()
• Model.$where()
• Model.aggregate()
• Model.applyDefaults()
• Model.applyTimestamps()
• Model.applyVirtuals()
• Model.bulkSave()
• Model.bulkWrite()
• Model.castObject()
• Model.cleanIndexes()
• Model.countDocuments()
• Model.create()
• Model.createCollection()
• Model.createIndexes()
• Model.createSearchIndex()
• Model.db
• Model.deleteMany()
• Model.deleteOne()
• Model.diffIndexes()
• Model.discriminator()
• Model.distinct()
• Model.dropSearchIndex()
• Model.ensureIndexes()
• Model.estimatedDocumentCount()
• Model.events
• Model.exists()
• Model.find()
• Model.findById()
• Model.findByIdAndDelete()
• Model.findByIdAndUpdate()
• Model.findOne()
• Model.findOneAndDelete()
• Model.findOneAndReplace()
• Model.findOneAndUpdate()
• Model.hydrate()
• Model.init()
• Model.insertMany()
• Model.insertOne()
• Model.inspect()
• Model.listIndexes()
• Model.listSearchIndexes()
• Model.namespace()
• Model.populate()
• Model.prototype.$model()
• Model.prototype.$where
• Model.prototype.base
• Model.prototype.baseModelName
• Model.prototype.collection
• Model.prototype.db
• Model.prototype.deleteOne()
• Model.prototype.discriminators
• Model.prototype.increment()
• Model.prototype.model()
• Model.prototype.modelName
• Model.prototype.save()
• Model.recompileSchema()
• Model.replaceOne()
• Model.schema
• Model.startSession()
• Model.syncIndexes()
• Model.translateAliases()
• Model.updateMany()
• Model.updateOne()
• Model.updateSearchIndex()
• Model.useConnection()
• Model.validate()
• Model.watch()
• Model.where()
• Mongoose()
• Mongoose.prototype.Aggregate()
• Mongoose.prototype.CastError()
• Mongoose.prototype.Collection()
• Mongoose.prototype.Connection()
• Mongoose.prototype.ConnectionStates
• Mongoose.prototype.Date
• Mongoose.prototype.Decimal128
• Mongoose.prototype.Document()
• Mongoose.prototype.DocumentProvider()
• Mongoose.prototype.Error()
• Mongoose.prototype.Mixed
• Mongoose.prototype.Model()
• Mongoose.prototype.Mongoose()
• Mongoose.prototype.Number
• Mongoose.prototype.ObjectId
• Mongoose.prototype.Query()
• Mongoose.prototype.STATES
• Mongoose.prototype.Schema()
• Mongoose.prototype.SchemaType()
• Mongoose.prototype.SchemaTypeOptions()
• Mongoose.prototype.SchemaTypes
• Mongoose.prototype.Types
• Mongoose.prototype.VirtualType()
• Mongoose.prototype.connect()
• Mongoose.prototype.connection
• Mongoose.prototype.connections
• Mongoose.prototype.createConnection()
• Mongoose.prototype.deleteModel()
• Mongoose.prototype.disconnect()
• Mongoose.prototype.driver
• Mongoose.prototype.get()
• Mongoose.prototype.isObjectIdOrHexString()
• Mongoose.prototype.isValidObjectId()
• Mongoose.prototype.model()
• Mongoose.prototype.modelNames()
• Mongoose.prototype.mquery
• Mongoose.prototype.now()
• Mongoose.prototype.omitUndefined()
• Mongoose.prototype.overwriteMiddlewareResult()
• Mongoose.prototype.plugin()
• Mongoose.prototype.pluralize()
• Mongoose.prototype.sanitizeFilter()
• Mongoose.prototype.set()
• Mongoose.prototype.setDriver()
• Mongoose.prototype.skipMiddlewareFunction()
• Mongoose.prototype.startSession()
• Mongoose.prototype.syncIndexes()
• Mongoose.prototype.trusted()
• Mongoose.prototype.version
• MongooseArray.prototype.$pop()
• MongooseArray.prototype.$shift()
• MongooseArray.prototype.addToSet()
• MongooseArray.prototype.includes()
• MongooseArray.prototype.indexOf()
• MongooseArray.prototype.inspect()
• MongooseArray.prototype.nonAtomicPush()
• MongooseArray.prototype.pop()
• MongooseArray.prototype.pull()
• MongooseArray.prototype.push()
• MongooseArray.prototype.remove()
• MongooseArray.prototype.set()
• MongooseArray.prototype.shift()
• MongooseArray.prototype.sort()
• MongooseArray.prototype.splice()
• MongooseArray.prototype.toObject()
• MongooseArray.prototype.unshift()
• MongooseBuffer.mixin.copy()
• MongooseBuffer.mixin.equals()
• MongooseBuffer.mixin.subtype()
• MongooseBuffer.mixin.toBSON()
• MongooseBuffer.mixin.toObject()
• MongooseBuffer.mixin.write()
• MongooseDocumentArray.prototype.create()
• MongooseDocumentArray.prototype.id()
• MongooseDocumentArray.prototype.inspect()
• MongooseDocumentArray.prototype.pull()
• MongooseDocumentArray.prototype.push()
• MongooseDocumentArray.prototype.toObject()
• MongooseMap.prototype.$isMongooseMap
• MongooseMap.prototype.clear()
• MongooseMap.prototype.delete()
• MongooseMap.prototype.get()
• MongooseMap.prototype.set()
• MongooseMap.prototype.toBSON()
• MongooseMap.prototype.toJSON()
• Query()
• Query.prototype.$where()
• Query.prototype.all()
• Query.prototype.allowDiskUse()
• Query.prototype.and()
• Query.prototype.batchSize()
• Query.prototype.box()
• Query.prototype.cast()
• Query.prototype.catch()
• Query.prototype.center()
• Query.prototype.centerSphere()
• Query.prototype.circle()
• Query.prototype.clone()
• Query.prototype.collation()
• Query.prototype.comment()
• Query.prototype.countDocuments()
• Query.prototype.cursor()
• Query.prototype.deleteMany()
• Query.prototype.deleteOne()
• Query.prototype.distinct()
• Query.prototype.elemMatch()
• Query.prototype.equals()
• Query.prototype.error()
• Query.prototype.estimatedDocumentCount()
• Query.prototype.exec()
• Query.prototype.exists()
• Query.prototype.explain()
• Query.prototype.finally()
• Query.prototype.find()
• Query.prototype.findOne()
• Query.prototype.findOneAndDelete()
• Query.prototype.findOneAndReplace()
• Query.prototype.findOneAndUpdate()
• Query.prototype.geometry()
• Query.prototype.get()
• Query.prototype.getFilter()
• Query.prototype.getOptions()
• Query.prototype.getPopulatedPaths()
• Query.prototype.getQuery()
• Query.prototype.getUpdate()
• Query.prototype.gt()
• Query.prototype.gte()
• Query.prototype.hint()
• Query.prototype.in()
• Query.prototype.intersects()
• Query.prototype.isPathSelectedInclusive()
• Query.prototype.j()
• Query.prototype.lean()
• Query.prototype.limit()
• Query.prototype.lt()
• Query.prototype.lte()
• Query.prototype.maxDistance()
• Query.prototype.maxTimeMS()
• Query.prototype.merge()
• Query.prototype.mod()
• Query.prototype.model
• Query.prototype.mongooseOptions()
• Query.prototype.ne()
• Query.prototype.near()
• Query.prototype.nearSphere()
• Query.prototype.nin()
• Query.prototype.nor()
• Query.prototype.or()
• Query.prototype.orFail()
• Query.prototype.polygon()
• Query.prototype.populate()
• Query.prototype.post()
• Query.prototype.pre()
• Query.prototype.projection()
• Query.prototype.read()
• Query.prototype.readConcern()
• Query.prototype.regex()
• Query.prototype.replaceOne()
• Query.prototype.sanitizeProjection()
• Query.prototype.schemaLevelProjections()
• Query.prototype.select()
• Query.prototype.selected()
• Query.prototype.selectedExclusively()
• Query.prototype.selectedInclusively()
• Query.prototype.session()
• Query.prototype.set()
• Query.prototype.setOptions()
• Query.prototype.setQuery()
• Query.prototype.setUpdate()
• Query.prototype.size()
• Query.prototype.skip()
• Query.prototype.slice()
• Query.prototype.sort()
• Query.prototype.tailable()
• Query.prototype.then()
• Query.prototype.toConstructor()
• Query.prototype.transform()
• Query.prototype.updateMany()
• Query.prototype.updateOne()
• Query.prototype.w()
• Query.prototype.where()
• Query.prototype.within()
• Query.prototype.writeConcern()
• Query.prototype.wtimeout()
• Query.prototype[Symbol.asyncIterator]()
• Query.prototype[Symbol.toStringTag]()
• Query.use$geoWithin
• QueryCursor()
• QueryCursor.prototype.addCursorFlag()
• QueryCursor.prototype.close()
• QueryCursor.prototype.eachAsync()
• QueryCursor.prototype.getDriverCursor()
• QueryCursor.prototype.map()
• QueryCursor.prototype.next()
• QueryCursor.prototype.options
• QueryCursor.prototype.rewind()
• QueryCursor.prototype[Symbol.asyncIterator]()
• Schema()
• Schema.Types
• Schema.indexTypes
• Schema.prototype.add()
• Schema.prototype.alias()
• Schema.prototype.childSchemas
• Schema.prototype.clearIndexes()
• Schema.prototype.clone()
• Schema.prototype.discriminator()
• Schema.prototype.eachPath()
• Schema.prototype.get()
• Schema.prototype.index()
• Schema.prototype.indexes()
• Schema.prototype.loadClass()
• Schema.prototype.method()
• Schema.prototype.obj
• Schema.prototype.omit()
• Schema.prototype.path()
• Schema.prototype.pathType()
• Schema.prototype.paths
• Schema.prototype.pick()
• Schema.prototype.plugin()
• Schema.prototype.post()
• Schema.prototype.pre()
• Schema.prototype.queue()
• Schema.prototype.remove()
• Schema.prototype.removeIndex()
• Schema.prototype.removeVirtual()
• Schema.prototype.requiredPaths()
• Schema.prototype.searchIndex()
• Schema.prototype.set()
• Schema.prototype.static()
• Schema.prototype.toJSONSchema()
• Schema.prototype.virtual()
• Schema.prototype.virtualpath()
• Schema.prototype.virtuals
• Schema.reserved
• SchemaArray()
• SchemaArray.checkRequired()
• SchemaArray.get()
• SchemaArray.options
• SchemaArray.prototype.checkRequired()
• SchemaArray.prototype.enum()
• SchemaArray.prototype.toJSONSchema()
• SchemaArray.schemaName
• SchemaArray.set()
• SchemaBoolean()
• SchemaBoolean.checkRequired()
• SchemaBoolean.convertToFalse
• SchemaBoolean.convertToTrue
• SchemaBoolean.get()
• SchemaBoolean.prototype.checkRequired()
• SchemaBoolean.prototype.toJSONSchema()
• SchemaBoolean.schemaName
• SchemaBoolean.set()
• SchemaBuffer()
• SchemaBuffer.checkRequired()
• SchemaBuffer.get()
• SchemaBuffer.prototype.checkRequired()
• SchemaBuffer.prototype.subtype()
• SchemaBuffer.prototype.toJSONSchema()
• SchemaBuffer.schemaName
• SchemaBuffer.set()
• SchemaDateOptions()
• SchemaDateOptions.prototype.expires
• SchemaDateOptions.prototype.max
• SchemaDateOptions.prototype.min
• SchemaDocumentArray()
• SchemaDocumentArray.get()
• SchemaDocumentArray.options
• SchemaDocumentArray.prototype.discriminator()
• SchemaDocumentArray.prototype.toJSONSchema()
• SchemaDocumentArray.schemaName
• SchemaDocumentArray.set()
• SchemaNumber()
• SchemaNumber.checkRequired()
• SchemaNumber.get()
• SchemaNumber.prototype.checkRequired()
• SchemaNumber.prototype.enum()
• SchemaNumber.prototype.max()
• SchemaNumber.prototype.min()
• SchemaNumber.prototype.toJSONSchema()
• SchemaNumber.schemaName
• SchemaNumber.set()
• SchemaObjectId()
• SchemaObjectId.checkRequired()
• SchemaObjectId.get()
• SchemaObjectId.prototype.auto()
• SchemaObjectId.prototype.checkRequired()
• SchemaObjectId.prototype.toJSONSchema()
• SchemaObjectId.schemaName
• SchemaObjectId.set()
• SchemaString()
• SchemaString.checkRequired()
• SchemaString.get()
• SchemaString.prototype.checkRequired()
• SchemaString.prototype.enum()
• SchemaString.prototype.lowercase()
• SchemaString.prototype.match()
• SchemaString.prototype.maxlength()
• SchemaString.prototype.minlength()
• SchemaString.prototype.toJSONSchema()
• SchemaString.prototype.trim()
• SchemaString.prototype.uppercase()
• SchemaString.schemaName
• SchemaString.set()
• SchemaSubdocument()
• SchemaSubdocument.get()
• SchemaSubdocument.prototype.discriminator()
• SchemaSubdocument.prototype.toJSONSchema()
• SchemaSubdocument.set()
• SchemaType()
• SchemaType.cast()
• SchemaType.checkRequired()
• SchemaType.get()
• SchemaType.prototype.cast()
• SchemaType.prototype.castFunction()
• SchemaType.prototype.default()
• SchemaType.prototype.doValidate()
• SchemaType.prototype.get()
• SchemaType.prototype.getEmbeddedSchemaType()
• SchemaType.prototype.immutable()
• SchemaType.prototype.index()
• SchemaType.prototype.isRequired
• SchemaType.prototype.path
• SchemaType.prototype.ref()
• SchemaType.prototype.required()
• SchemaType.prototype.select()
• SchemaType.prototype.set()
• SchemaType.prototype.sparse()
• SchemaType.prototype.text()
• SchemaType.prototype.toJSONSchema()
• SchemaType.prototype.transform()
• SchemaType.prototype.unique()
• SchemaType.prototype.validate()
• SchemaType.prototype.validateAll()
• SchemaType.prototype.validators
• SchemaType.set()
• SchemaTypeOptions()
• SchemaTypeOptions.prototype.cast
• SchemaTypeOptions.prototype.default
• SchemaTypeOptions.prototype.immutable
• SchemaTypeOptions.prototype.index
• SchemaTypeOptions.prototype.ref
• SchemaTypeOptions.prototype.required
• SchemaTypeOptions.prototype.select
• SchemaTypeOptions.prototype.sparse
• SchemaTypeOptions.prototype.text
• SchemaTypeOptions.prototype.transform
• SchemaTypeOptions.prototype.type
• SchemaTypeOptions.prototype.unique
• SchemaTypeOptions.prototype.validate
• Subdocument.prototype.$parent()
• Subdocument.prototype.deleteOne()
• Subdocument.prototype.inspect()
• Subdocument.prototype.ownerDocument()
• Subdocument.prototype.parent()
• VirtualType()
• VirtualType.prototype.applyGetters()
• VirtualType.prototype.applySetters()
• VirtualType.prototype.get()
• VirtualType.prototype.set()
• _handlePreHookError()

Modules

• Aggregate
• AggregationCursor
• Array
• ArraySubdocument
• Buffer
• Connection
• Decimal128
• Document
• DocumentArray
• Error
• Map
• Model
• Mongoose
• Query
• QueryCursor
• Schema
• SchemaArray
• SchemaBoolean
• SchemaBuffer
• SchemaDateOptions
• SchemaDocumentArray
• SchemaNumber
• SchemaObjectId
• SchemaString
• SchemaSubdocument
• SchemaType
• SchemaTypeOptions
• Subdocument
• VirtualType