Merge pull request #14260 from Automattic/8.1

8.1

Author: vkarpov15

.github/workflows/tsd.yml

@@ -7,8 +7,6 @@ on:
       - 'types/**'
       - 'test/types/**'
   push:
-    branches:
-      - master
     paths:
       - '.github/workflows/tsd.yml'
       - 'package.json'

docs/guide.md

@@ -558,6 +558,7 @@ Valid options:
 * [collectionOptions](#collectionOptions)
 * [methods](#methods)
 * [query](#query-helpers)
+* [autoSearchIndex](#autoSearchIndex)
 
 <h2 id="autoIndex"><a href="#autoIndex">option: autoIndex</a></h2>
 
@@ -1453,6 +1454,25 @@ const Test = mongoose.model('Test', schema);
 await Test.createCollection();
 ```
 
+<h2 id="autoSearchIndex">
+  <a href="#autoSearchIndex">
+    option: autoSearchIndex
+  </a>
+</h2>
+
+Similar to [`autoIndex`](#autoIndex), except for automatically creates any [Atlas search indexes](https://www.mongodb.com/docs/atlas/atlas-search/create-index/) defined in your schema.
+Unlike `autoIndex`, this option defaults to false.
+
+```javascript
+const schema = new Schema({ name: String }, { autoSearchIndex: true });
+schema.searchIndex({
+  name: 'my-index',
+  definition: { mappings: { dynamic: true } }
+});
+// Will automatically attempt to create the `my-index` search index.
+const Test = mongoose.model('Test', schema);
+``
+
 <h2 id="es6-classes"><a href="#es6-classes">With ES6 Classes</a></h2>
 
 Schemas have a [`loadClass()` method](api/schema.html#schema_Schema-loadClass)

lib/connection.js

@@ -605,6 +605,26 @@ Connection.prototype.dropCollection = async function dropCollection(collection)
   return this.db.dropCollection(collection);
 };
 
+/**
+ * Helper for MongoDB Node driver's `listCollections()`.
+ * Returns an array of collection objects.
+ *
+ * @method listCollections
+ * @return {Promise<Collection[]>}
+ * @api public
+ */
+
+Connection.prototype.listCollections = async function listCollections() {
+  if ((this.readyState === STATES.connecting || this.readyState === STATES.disconnected) && this._shouldBufferCommands()) {
+    await new Promise(resolve => {
+      this._queue.push({ fn: resolve });
+    });
+  }
+
+  const cursor = this.db.listCollections();
+  return await cursor.toArray();
+};
+
 /**
  * Helper for `dropDatabase()`. Deletes the given database, including all
  * collections, documents, and indexes.
@@ -983,7 +1003,8 @@ Connection.prototype.onClose = function(force) {
 Connection.prototype.collection = function(name, options) {
   const defaultOptions = {
     autoIndex: this.config.autoIndex != null ? this.config.autoIndex : this.base.options.autoIndex,
-    autoCreate: this.config.autoCreate != null ? this.config.autoCreate : this.base.options.autoCreate
+    autoCreate: this.config.autoCreate != null ? this.config.autoCreate : this.base.options.autoCreate,
+    autoSearchIndex: this.config.autoSearchIndex != null ? this.config.autoSearchIndex : this.base.options.autoSearchIndex
   };
   options = Object.assign({}, defaultOptions, options ? clone(options) : {});
   options.$wasForceClosed = this.$wasForceClosed;

lib/drivers/node-mongodb-native/connection.js

@@ -246,6 +246,11 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
       delete options.sanitizeFilter;
     }
 
+    if ('autoSearchIndex' in options) {
+      this.config.autoSearchIndex = options.autoSearchIndex;
+      delete options.autoSearchIndex;
+    }
+
     // Backwards compat
     if (options.user || options.pass) {
       options.auth = options.auth || {};

lib/model.js

@@ -1273,10 +1273,14 @@ for (const i in EventEmitter.prototype) {
 }
 
 /**
- * This function is responsible for building [indexes](https://www.mongodb.com/docs/manual/indexes/),
- * unless [`autoIndex`](https://mongoosejs.com/docs/guide.html#autoIndex) is turned off.
+ * This function is responsible for initializing the underlying connection in MongoDB based on schema options.
+ * This function performs the following operations:
  *
- * Mongoose calls this function automatically when a model is created using
+ * - `createCollection()` unless [`autoCreate`](https://mongoosejs.com/docs/guide.html#autoCreate) option is turned off
+ * - `ensureIndexes()` unless [`autoIndex`](https://mongoosejs.com/docs/guide.html#autoIndex) option is turned off
+ * - `createSearchIndex()` on all schema search indexes if `autoSearchIndex` is enabled.
+ *
+ * Mongoose calls this function automatically when a model is a created using
  * [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.model()) or
  * [`connection.model()`](https://mongoosejs.com/docs/api/connection.html#Connection.prototype.model()), so you
  * don't need to call `init()` to trigger index builds.
@@ -1324,6 +1328,23 @@ Model.init = function init() {
     }
     return await this.ensureIndexes({ _automatic: true });
   };
+  const _createSearchIndexes = async() => {
+    const autoSearchIndex = utils.getOption(
+      'autoSearchIndex',
+      this.schema.options,
+      conn.config,
+      conn.base.options
+    );
+    if (!autoSearchIndex) {
+      return;
+    }
+
+    const results = [];
+    for (const searchIndex of this.schema._searchIndexes) {
+      results.push(await this.createSearchIndex(searchIndex));
+    }
+    return results;
+  };
   const _createCollection = async() => {
     if ((conn.readyState === STATES.connecting || conn.readyState === STATES.disconnected) && conn._shouldBufferCommands()) {
       await new Promise(resolve => {
@@ -1342,7 +1363,9 @@ Model.init = function init() {
     return await this.createCollection();
   };
 
-  this.$init = _createCollection().then(() => _ensureIndexes());
+  this.$init = _createCollection().
+    then(() => _ensureIndexes()).
+    then(() => _createSearchIndexes());
 
   const _catch = this.$init.catch;
   const _this = this;
@@ -1506,6 +1529,72 @@ Model.syncIndexes = async function syncIndexes(options) {
   return dropped;
 };
 
+/**
+ * Create an [Atlas search index](https://www.mongodb.com/docs/atlas/atlas-search/create-index/).
+ * This function only works when connected to MongoDB Atlas.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({ name: { type: String, unique: true } });
+ *     const Customer = mongoose.model('Customer', schema);
+ *     await Customer.createSearchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
+ *
+ * @param {Object} description index options, including `name` and `definition`
+ * @param {String} description.name
+ * @param {Object} description.definition
+ * @return {Promise}
+ * @api public
+ */
+
+Model.createSearchIndex = async function createSearchIndex(description) {
+  _checkContext(this, 'createSearchIndex');
+
+  return await this.$__collection.createSearchIndex(description);
+};
+
+/**
+ * Update an existing [Atlas search index](https://www.mongodb.com/docs/atlas/atlas-search/create-index/).
+ * This function only works when connected to MongoDB Atlas.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({ name: { type: String, unique: true } });
+ *     const Customer = mongoose.model('Customer', schema);
+ *     await Customer.updateSearchIndex('test', { mappings: { dynamic: true } });
+ *
+ * @param {String} name
+ * @param {Object} definition
+ * @return {Promise}
+ * @api public
+ */
+
+Model.updateSearchIndex = async function updateSearchIndex(name, definition) {
+  _checkContext(this, 'updateSearchIndex');
+
+  return await this.$__collection.updateSearchIndex(name, definition);
+};
+
+/**
+ * Delete an existing [Atlas search index](https://www.mongodb.com/docs/atlas/atlas-search/create-index/) by name.
+ * This function only works when connected to MongoDB Atlas.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({ name: { type: String, unique: true } });
+ *     const Customer = mongoose.model('Customer', schema);
+ *     await Customer.dropSearchIndex('test');
+ *
+ * @param {String} name
+ * @return {Promise}
+ * @api public
+ */
+
+Model.dropSearchIndex = async function dropSearchIndex(name) {
+  _checkContext(this, 'dropSearchIndex');
+
+  return await this.$__collection.dropSearchIndex(name);
+};
+
 /**
  * Does a dry-run of `Model.syncIndexes()`, returning the indexes that `syncIndexes()` would drop and create if you were to run `syncIndexes()`.
  *

lib/mongoose.js

@@ -65,7 +65,8 @@ function Mongoose(options) {
   this.options = Object.assign({
     pluralization: true,
     autoIndex: true,
-    autoCreate: true
+    autoCreate: true,
+    autoSearchIndex: false
   }, options);
   const createInitialConnection = utils.getOption('createInitialConnection', this.options);
   if (createInitialConnection == null || createInitialConnection) {

lib/schema.js

@@ -116,6 +116,7 @@ function Schema(obj, options) {
   this.inherits = {};
   this.callQueue = [];
   this._indexes = [];
+  this._searchIndexes = [];
   this.methods = (options && options.methods) || {};
   this.methodOptions = {};
   this.statics = (options && options.statics) || {};
@@ -411,6 +412,7 @@ Schema.prototype._clone = function _clone(Constructor) {
   s.query = clone(this.query);
   s.plugins = Array.prototype.slice.call(this.plugins);
   s._indexes = clone(this._indexes);
+  s._searchIndexes = clone(this._searchIndexes);
   s.s.hooks = this.s.hooks.clone();
 
   s.tree = clone(this.tree);
@@ -908,6 +910,28 @@ Schema.prototype.clearIndexes = function clearIndexes() {
   return this;
 };
 
+/**
+ * Add an [Atlas search index](https://www.mongodb.com/docs/atlas/atlas-search/create-index/) that Mongoose will create using `Model.createSearchIndex()`.
+ * This function only works when connected to MongoDB Atlas.
+ *
+ * #### Example:
+ *
+ *     const ToySchema = new Schema({ name: String, color: String, price: Number });
+ *     ToySchema.searchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
+ *
+ * @param {Object} description index options, including `name` and `definition`
+ * @param {String} description.name
+ * @param {Object} description.definition
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
+Schema.prototype.searchIndex = function searchIndex(description) {
+  this._searchIndexes.push(description);
+
+  return this;
+};
+
 /**
  * Reserved document keys.
  *

lib/schemaType.js

@@ -59,7 +59,9 @@ function SchemaType(path, options, instance) {
   const defaultOptionsKeys = Object.keys(defaultOptions);
 
   for (const option of defaultOptionsKeys) {
-    if (defaultOptions.hasOwnProperty(option) && !Object.prototype.hasOwnProperty.call(options, option)) {
+    if (option === 'validate') {
+      this.validate(defaultOptions.validate);
+    } else if (defaultOptions.hasOwnProperty(option) && !Object.prototype.hasOwnProperty.call(options, option)) {
       options[option] = defaultOptions[option];
     }
   }

lib/validOptions.js

@@ -11,6 +11,7 @@ const VALID_OPTIONS = Object.freeze([
   'applyPluginsToDiscriminators',
   'autoCreate',
   'autoIndex',
+  'autoSearchIndex',
   'bufferCommands',
   'bufferTimeoutMS',
   'cloneSchemas',

package.json

@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^6.2.0",
     "kareem": "2.5.1",
-    "mongodb": "6.2.0",
+    "mongodb": "6.3.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",

test/connection.test.js

@@ -94,7 +94,7 @@ describe('connections:', function() {
       }));
       await Model.init();
 
-      const res = await conn.db.listCollections().toArray();
+      const res = await conn.listCollections();
       assert.ok(!res.map(c => c.name).includes('gh8814_Conn'));
       await conn.close();
     });
@@ -185,16 +185,25 @@ describe('connections:', function() {
         size: 1024
       });
 
-      const collections = await conn.db.listCollections().toArray();
+      const collections = await conn.listCollections();
 
       const names = collections.map(function(c) { return c.name; });
       assert.ok(names.indexOf('gh5712') !== -1);
       assert.ok(collections[names.indexOf('gh5712')].options.capped);
       await conn.createCollection('gh5712_0');
-      const collectionsAfterCreation = await conn.db.listCollections().toArray();
+      const collectionsAfterCreation = await conn.listCollections();
       const newCollectionsNames = collectionsAfterCreation.map(function(c) { return c.name; });
       assert.ok(newCollectionsNames.indexOf('gh5712') !== -1);
     });
+
+    it('listCollections()', async function() {
+      await conn.dropDatabase();
+      await conn.createCollection('test1176');
+      await conn.createCollection('test94112');
+
+      const collections = await conn.listCollections();
+      assert.deepStrictEqual(collections.map(coll => coll.name).sort(), ['test1176', 'test94112']);
+    });
   });
 
   it('should allow closing a closed connection', async function() {

test/schematype.test.js

@@ -208,6 +208,37 @@ describe('schematype', function() {
     });
   });
 
+  it('merges default validators (gh-14070)', function() {
+    class TestSchemaType extends mongoose.SchemaType {}
+    TestSchemaType.set('validate', checkIfString);
+
+    const schemaType = new TestSchemaType('test-path', {
+      validate: checkIfLength2
+    });
+
+    assert.equal(schemaType.validators.length, 2);
+    assert.equal(schemaType.validators[0].validator, checkIfString);
+    assert.equal(schemaType.validators[1].validator, checkIfLength2);
+
+    let err = schemaType.doValidateSync([1, 2]);
+    assert.ok(err);
+    assert.equal(err.name, 'ValidatorError');
+
+    err = schemaType.doValidateSync('foo');
+    assert.ok(err);
+    assert.equal(err.name, 'ValidatorError');
+
+    err = schemaType.doValidateSync('ab');
+    assert.ifError(err);
+
+    function checkIfString(v) {
+      return typeof v === 'string';
+    }
+    function checkIfLength2(v) {
+      return v.length === 2;
+    }
+  });
+
   describe('set()', function() {
     describe('SchemaType.set()', function() {
       it('SchemaType.set, is a function', () => {

test/types/connection.test.ts

@@ -70,6 +70,10 @@ expectType<Connection>(conn.useDb('test', {}));
 expectType<Connection>(conn.useDb('test', { noListener: true }));
 expectType<Connection>(conn.useDb('test', { useCache: true }));
 
+expectType<Promise<string[]>>(
+  conn.listCollections().then(collections => collections.map(coll => coll.name))
+);
+
 export function autoTypedModelConnection() {
   const AutoTypedSchema = autoTypedSchema();
   const AutoTypedModel = connection.model('AutoTypeModelConnection', AutoTypedSchema);