diff --git a/docs/guide.pug b/docs/guide.pug
index 5a4df7761f..92f54d4312 100644
--- a/docs/guide.pug
+++ b/docs/guide.pug
@@ -421,6 +421,7 @@ block content
- [bufferTimeoutMS](#bufferTimeoutMS)
- [capped](#capped)
- [collection](#collection)
+ - [discriminatorKey](#discriminatorKey)
- [id](#id)
- [_id](#_id)
- [minimize](#minimize)
@@ -545,6 +546,25 @@ block content
const dataSchema = new Schema({..}, { collection: 'data' });
```
+
+
+ When you define a [discriminator](/docs/discriminators.html), Mongoose adds a path to your
+ schema that stores which discriminator a document is an instance of. By default, Mongoose
+ adds an `__t` path, but you can set `discriminatorKey` to overwrite this default.
+
+ ```javascript
+ const baseSchema = new Schema({}, { discriminatorKey: 'type' });
+ const BaseModel = mongoose.model('Test', baseSchema);
+
+ const personSchema = new Schema({ name: String });
+ const PersonModel = BaseModel.discriminator('Person', personSchema);
+
+ const doc = new PersonModel({ name: 'James T. Kirk' });
+ // Without `discriminatorKey`, Mongoose would store the discriminator
+ // key in `__t` instead of `type`
+ doc.type; // 'Person'
+ ```
+
Mongoose assigns each of your schemas an `id` virtual getter by default
diff --git a/index.d.ts b/index.d.ts
index a4d3ae6aa5..799f7432fd 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -745,6 +745,17 @@ declare module "mongoose" {
j?: boolean;
w?: number | string;
wtimeout?: number;
+ safe?: boolean | WriteConcern;
+ }
+
+ interface WriteConcern {
+ j?: boolean;
+ w?: number | 'majority' | TagSet;
+ wtimeout?: number;
+ }
+
+ interface TagSet {
+ [k: string]: string;
}
interface InsertManyOptions {
@@ -857,7 +868,7 @@ declare module "mongoose" {
/**
* Create a new schema
*/
- constructor(definition?: SchemaDefinition);
+ constructor(definition?: SchemaDefinition, options?: SchemaOptions);
/** Adds key path / schema type pairs to this schema. */
add(obj: SchemaDefinition | Schema, prefix?: string): this;
@@ -946,6 +957,168 @@ declare module "mongoose" {
[path: string]: SchemaTypeOptions | Function | string | Schema | Array | Array>;
}
+ interface SchemaOptions {
+ /**
+ * By default, Mongoose's init() function creates all the indexes defined in your model's schema by
+ * calling Model.createIndexes() after you successfully connect to MongoDB. If you want to disable
+ * automatic index builds, you can set autoIndex to false.
+ */
+ autoIndex?: boolean;
+ /**
+ * If set to `true`, Mongoose will call Model.createCollection() to create the underlying collection
+ * in MongoDB if autoCreate is set to true. Calling createCollection() sets the collection's default
+ * collation based on the collation option and establishes the collection as a capped collection if
+ * you set the capped schema option.
+ */
+ autoCreate?: boolean;
+ /**
+ * By default, mongoose buffers commands when the connection goes down until the driver manages to reconnect.
+ * To disable buffering, set bufferCommands to false.
+ */
+ bufferCommands?: boolean;
+ /**
+ * If bufferCommands is on, this option sets the maximum amount of time Mongoose buffering will wait before
+ * throwing an error. If not specified, Mongoose will use 10000 (10 seconds).
+ */
+ bufferTimeoutMS?: number;
+ /**
+ * Mongoose supports MongoDBs capped collections. To specify the underlying MongoDB collection be capped, set
+ * the capped option to the maximum size of the collection in bytes.
+ */
+ capped?: boolean | number | { size?: number; max?: number; autoIndexId?: boolean; };
+ /** Sets a default collation for every query and aggregation. */
+ collation?: mongodb.CollationDocument;
+ /**
+ * Mongoose by default produces a collection name by passing the model name to the utils.toCollectionName
+ * method. This method pluralizes the name. Set this option if you need a different name for your collection.
+ */
+ collection?: string;
+ /**
+ * When you define a [discriminator](/docs/discriminators.html), Mongoose adds a path to your
+ * schema that stores which discriminator a document is an instance of. By default, Mongoose
+ * adds an `__t` path, but you can set `discriminatorKey` to overwrite this default.
+ */
+ discriminatorKey?: string;
+ /** defaults to false. */
+ emitIndexErrors?: boolean;
+ excludeIndexes?: any;
+ /**
+ * Mongoose assigns each of your schemas an id virtual getter by default which returns the document's _id field
+ * cast to a string, or in the case of ObjectIds, its hexString.
+ */
+ id?: boolean;
+ /**
+ * Mongoose assigns each of your schemas an _id field by default if one is not passed into the Schema
+ * constructor. The type assigned is an ObjectId to coincide with MongoDB's default behavior. If you
+ * don't want an _id added to your schema at all, you may disable it using this option.
+ */
+ _id?: boolean;
+ /**
+ * Mongoose will, by default, "minimize" schemas by removing empty objects. This behavior can be
+ * overridden by setting minimize option to false. It will then store empty objects.
+ */
+ minimize?: boolean;
+ /**
+ * Optimistic concurrency is a strategy to ensure the document you're updating didn't change between when you
+ * loaded it using find() or findOne(), and when you update it using save(). Set to `true` to enable
+ * optimistic concurrency.
+ */
+ optimisticConcurrency?: boolean;
+ /**
+ * Allows setting query#read options at the schema level, providing us a way to apply default ReadPreferences
+ * to all queries derived from a model.
+ */
+ read?: string;
+ /** Allows setting write concern at the schema level. */
+ writeConcern?: WriteConcern;
+ /** defaults to true. */
+ safe?: boolean | { w?: number | string; wtimeout?: number; j?: boolean };
+ /**
+ * The shardKey option is used when we have a sharded MongoDB architecture. Each sharded collection is
+ * given a shard key which must be present in all insert/update operations. We just need to set this
+ * schema option to the same shard key and we'll be all set.
+ */
+ shardKey?: object;
+ /**
+ * For backwards compatibility, the strict option does not apply to the filter parameter for queries.
+ * Mongoose has a separate strictQuery option to toggle strict mode for the filter parameter to queries.
+ */
+ strictQuery?: boolean | "throw";
+ /**
+ * The strict option, (enabled by default), ensures that values passed to our model constructor that were not
+ * specified in our schema do not get saved to the db.
+ */
+ strict?: boolean | "throw";
+ /** Exactly the same as the toObject option but only applies when the document's toJSON method is called. */
+ toJSON?: ToObjectOptions;
+ /**
+ * Documents have a toObject method which converts the mongoose document into a plain JavaScript object.
+ * This method accepts a few options. Instead of applying these options on a per-document basis, we may
+ * declare the options at the schema level and have them applied to all of the schema's documents by
+ * default.
+ */
+ toObject?: ToObjectOptions;
+ /**
+ * By default, if you have an object with key 'type' in your schema, mongoose will interpret it as a
+ * type declaration. However, for applications like geoJSON, the 'type' property is important. If you want to
+ * control which key mongoose uses to find type declarations, set the 'typeKey' schema option.
+ */
+ typeKey?: string;
+ /**
+ * Write operations like update(), updateOne(), updateMany(), and findOneAndUpdate() only check the top-level
+ * schema's strict mode setting. Set to `true` to use the child schema's `strict` mode setting.
+ */
+ useNestedStrict?: boolean;
+ /** defaults to false */
+ usePushEach?: boolean;
+ /**
+ * By default, documents are automatically validated before they are saved to the database. This is to
+ * prevent saving an invalid document. If you want to handle validation manually, and be able to save
+ * objects which don't pass validation, you can set validateBeforeSave to false.
+ */
+ validateBeforeSave?: boolean;
+ /**
+ * The versionKey is a property set on each document when first created by Mongoose. This keys value
+ * contains the internal revision of the document. The versionKey option is a string that represents
+ * the path to use for versioning. The default is '__v'.
+ */
+ versionKey?: string | boolean;
+ /**
+ * By default, Mongoose will automatically select() any populated paths for you, unless you explicitly exclude them.
+ */
+ selectPopulatedPaths?: boolean;
+ /**
+ * skipVersioning allows excluding paths from versioning (i.e., the internal revision will not be
+ * incremented even if these paths are updated). DO NOT do this unless you know what you're doing.
+ * For subdocuments, include this on the parent document using the fully qualified path.
+ */
+ skipVersioning?: any;
+ /**
+ * Validation errors in a single nested schema are reported
+ * both on the child and on the parent schema.
+ * Set storeSubdocValidationError to false on the child schema
+ * to make Mongoose only report the parent error.
+ */
+ storeSubdocValidationError?: boolean;
+ /**
+ * The timestamps option tells mongoose to assign createdAt and updatedAt fields to your schema. The type
+ * assigned is Date. By default, the names of the fields are createdAt and updatedAt. Customize the
+ * field names by setting timestamps.createdAt and timestamps.updatedAt.
+ */
+ timestamps?: boolean | SchemaTimestampsConfig;
+ /**
+ * Determines whether a type set to a POJO becomes
+ * a Mixed path or a Subdocument (defaults to true).
+ */
+ typePojoToMixed?:boolean;
+ }
+
+ interface SchemaTimestampsConfig {
+ createdAt?: boolean | string;
+ updatedAt?: boolean | string;
+ currentTime?: () => (Date | number);
+ }
+
interface SchemaTypeOptions {
type?: T;