Merge pull request #13076 from Automattic/6.10

6.10

Author: vkarpov15

lib/index.js

@@ -71,8 +71,11 @@ function Mongoose(options) {
     autoIndex: true,
     autoCreate: true
   }, options);
-  const conn = this.createConnection(); // default connection
-  conn.models = this.models;
+  const createInitialConnection = utils.getOption('createInitialConnection', this.options);
+  if (createInitialConnection == null || createInitialConnection) {
+    const conn = this.createConnection(); // default connection
+    conn.models = this.models;
+  }
 
   if (this.options.pluralization) {
     this._pluralize = legacyPluralize;

lib/schema.js

@@ -478,6 +478,48 @@ Schema.prototype.pick = function(paths, options) {
   return newSchema;
 };
 
+/**
+ * Returns a new schema that has the `paths` from the original schema, minus the omitted ones.
+ *
+ * This method is analagous to [Lodash's `omit()` function](https://lodash.com/docs/#omit) for Mongoose schemas.
+ *
+ * #### Example:
+ *
+ *     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
+ *
+ * @param {String[]} paths List of Paths to omit for the new Schema
+ * @param {Object} [options] Options to pass to the new Schema Constructor (same as `new Schema(.., Options)`). Defaults to `this.options` if not set.
+ * @return {Schema}
+ * @api public
+ */
+
+Schema.prototype.omit = function(paths, options) {
+  const newSchema = new Schema(this, options || this.options);
+  if (!Array.isArray(paths)) {
+    throw new MongooseError(
+      'Schema#omit() only accepts an array argument, ' +
+        'got "' +
+        typeof paths +
+        '"'
+    );
+  }
+
+  newSchema.remove(paths);
+
+  for (const nested in newSchema.singleNestedPaths) {
+    if (paths.includes(nested)) {
+      delete newSchema.singleNestedPaths[nested];
+    }
+  }
+
+  return newSchema;
+};
+
 /**
  * Returns default options for this schema, merged with `options`.
  *

package.json

@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^4.7.0",
     "kareem": "2.5.1",
-    "mongodb": "4.13.0",
+    "mongodb": "4.14.0",
     "mpath": "0.9.0",
     "mquery": "4.0.3",
     "ms": "2.1.3",

test/connection.test.js

@@ -1545,4 +1545,11 @@ describe('connections:', function() {
     const res = await m.connection.db.listCollections().toArray();
     assert.ok(!res.map(c => c.name).includes('gh12940_Conn'));
   });
+
+  it('should not create default connection with createInitialConnection = false (gh-12965)', function() {
+    const m = new mongoose.Mongoose({
+      createInitialConnection: false
+    });
+    assert.deepEqual(m.connections.length, 0);
+  });
 });

test/schema.test.js

@@ -2339,6 +2339,81 @@ describe('schema', function() {
     });
   });
 
+  describe('omit() (gh-12931)', function() {
+    it('works with nested paths', function() {
+      const schema = Schema({
+        name: {
+          first: {
+            type: String,
+            required: true
+          },
+          last: {
+            type: String,
+            required: true
+          }
+        },
+        age: {
+          type: Number,
+          index: true
+        }
+      });
+      assert.ok(schema.path('name.first'));
+      assert.ok(schema.path('name.last'));
+
+      let newSchema = schema.omit(['name.first']);
+      assert.ok(!newSchema.path('name.first'));
+      assert.ok(newSchema.path('age'));
+      assert.ok(newSchema.path('age').index);
+
+      newSchema = schema.omit(['age']);
+      assert.ok(newSchema.path('name.first'));
+      assert.ok(newSchema.path('name.first').required);
+      assert.ok(newSchema.path('name.last'));
+      assert.ok(newSchema.path('name.last').required);
+      assert.ok(!newSchema.path('age'));
+
+      newSchema = schema.omit(['name.last', 'age']);
+      assert.ok(newSchema.path('name.first'));
+      assert.ok(newSchema.path('name.first').required);
+      assert.ok(!newSchema.path('name.last'));
+      assert.ok(!newSchema.path('age'));
+    });
+
+    it('with single nested paths', function() {
+      const schema = Schema({
+        name: Schema({
+          first: {
+            type: String,
+            required: true
+          },
+          last: {
+            type: String,
+            required: true
+          }
+        }),
+        age: {
+          type: Number,
+          index: true
+        }
+      });
+      assert.ok(schema.path('name.first'));
+      assert.ok(schema.path('name.last'));
+
+      let newSchema = schema.omit(['age']);
+      assert.ok(newSchema.path('name.first'));
+      assert.ok(newSchema.path('name.first').required);
+      assert.ok(newSchema.path('name.last'));
+      assert.ok(newSchema.path('name.last').required);
+      assert.ok(!newSchema.path('age'));
+
+      newSchema = schema.omit(['name.last', 'age']);
+      assert.ok(newSchema.path('name.first'));
+      assert.ok(newSchema.path('name.first').required);
+      assert.ok(!newSchema.path('name.last'));
+      assert.ok(!newSchema.path('age'));
+    });
+  });
+
   describe('path-level custom cast (gh-8300)', function() {
     it('with numbers', function() {
       const schema = Schema({

types/mongooseoptions.d.ts

@@ -63,6 +63,13 @@ declare module 'mongoose' {
      */
     cloneSchemas?: boolean;
 
+    /**
+     * Set to `false` to disable the creation of the initial default connection.
+     *
+     * @default true
+     */
+    createInitialConnection?: boolean;
+
     /**
      * If `true`, prints the operations mongoose sends to MongoDB to the console.
      * If a writable stream is passed, it will log to that stream, without colorization.