mongodb 3.6.10 → 3.7.1

package/lib/gridfs-stream/upload.js

@@ -1,14 +1,12 @@
 'use strict';
 
-var core = require('../core');
-var crypto = require('crypto');
-var stream = require('stream');
-var util = require('util');
-var Buffer = require('safe-buffer').Buffer;
-
-var ERROR_NAMESPACE_NOT_FOUND = 26;
-
-module.exports = GridFSBucketWriteStream;
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
+const core = require('../core');
+const crypto = require('crypto');
+const stream = require('stream');
+const util = require('util');
+const Buffer = require('safe-buffer').Buffer;
+const deprecateOptions = require('../utils').deprecateOptions;
 
 /**
  * A writable stream that enables you to write buffers to GridFS.
@@ -31,42 +29,49 @@ module.exports = GridFSBucketWriteStream;
  * @fires GridFSBucketWriteStream#finish
  */
 
-function GridFSBucketWriteStream(bucket, filename, options) {
-  options = options || {};
-  stream.Writable.call(this, options);
-  this.bucket = bucket;
-  this.chunks = bucket.s._chunksCollection;
-  this.filename = filename;
-  this.files = bucket.s._filesCollection;
-  this.options = options;
-  // Signals the write is all done
-  this.done = false;
-
-  this.id = options.id ? options.id : core.BSON.ObjectId();
-  this.chunkSizeBytes = this.options.chunkSizeBytes;
-  this.bufToStore = Buffer.alloc(this.chunkSizeBytes);
-  this.length = 0;
-  this.md5 = !options.disableMD5 && crypto.createHash('md5');
-  this.n = 0;
-  this.pos = 0;
-  this.state = {
-    streamEnd: false,
-    outstandingRequests: 0,
-    errored: false,
-    aborted: false,
-    promiseLibrary: this.bucket.s.promiseLibrary
-  };
-
-  if (!this.bucket.s.calledOpenUploadStream) {
-    this.bucket.s.calledOpenUploadStream = true;
-
-    var _this = this;
-    checkIndexes(this, function() {
-      _this.bucket.s.checkedIndexes = true;
-      _this.bucket.emit('index');
-    });
+const GridFSBucketWriteStream = deprecateOptions(
+  {
+    name: 'GridFSBucketWriteStream',
+    deprecatedOptions: ['disableMD5'],
+    optionsIndex: 2
+  },
+  function(bucket, filename, options) {
+    options = options || {};
+    stream.Writable.call(this, options);
+    this.bucket = bucket;
+    this.chunks = bucket.s._chunksCollection;
+    this.filename = filename;
+    this.files = bucket.s._filesCollection;
+    this.options = options;
+    // Signals the write is all done
+    this.done = false;
+
+    this.id = options.id ? options.id : core.BSON.ObjectId();
+    this.chunkSizeBytes = this.options.chunkSizeBytes;
+    this.bufToStore = Buffer.alloc(this.chunkSizeBytes);
+    this.length = 0;
+    this.md5 = !options.disableMD5 && crypto.createHash('md5');
+    this.n = 0;
+    this.pos = 0;
+    this.state = {
+      streamEnd: false,
+      outstandingRequests: 0,
+      errored: false,
+      aborted: false,
+      promiseLibrary: this.bucket.s.promiseLibrary
+    };
+
+    if (!this.bucket.s.calledOpenUploadStream) {
+      this.bucket.s.calledOpenUploadStream = true;
+
+      var _this = this;
+      checkIndexes(this, function() {
+        _this.bucket.s.checkedIndexes = true;
+        _this.bucket.emit('index');
+      });
+    }
   }
-}
+);
 
 util.inherits(GridFSBucketWriteStream, stream.Writable);
 
@@ -210,7 +215,7 @@ function checkChunksIndex(_this, callback) {
   _this.chunks.listIndexes().toArray(function(error, indexes) {
     if (error) {
       // Collection doesn't exist so create index
-      if (error.code === ERROR_NAMESPACE_NOT_FOUND) {
+      if (error.code === MONGODB_ERROR_CODES.NamespaceNotFound) {
         var index = { files_id: 1, n: 1 };
         _this.chunks.createIndex(index, { background: false, unique: true }, function(error) {
           if (error) {
@@ -309,7 +314,7 @@ function checkIndexes(_this, callback) {
     _this.files.listIndexes().toArray(function(error, indexes) {
       if (error) {
         // Collection doesn't exist so create index
-        if (error.code === ERROR_NAMESPACE_NOT_FOUND) {
+        if (error.code === MONGODB_ERROR_CODES.NamespaceNotFound) {
           var index = { filename: 1, uploadDate: 1 };
           _this.files.createIndex(index, { background: false }, function(error) {
             if (error) {
@@ -539,3 +544,5 @@ function checkAborted(_this, callback) {
   }
   return false;
 }
+
+module.exports = GridFSBucketWriteStream;

package/lib/mongo_client.js

@@ -5,6 +5,7 @@ const Db = require('./db');
 const EventEmitter = require('events').EventEmitter;
 const inherits = require('util').inherits;
 const MongoError = require('./core').MongoError;
+const ValidServerApiVersions = require('./core').ValidServerApiVersions;
 const deprecate = require('util').deprecate;
 const WriteConcern = require('./write_concern');
 const MongoDBNamespace = require('./utils').MongoDBNamespace;
@@ -156,6 +157,7 @@ const validOptions = require('./operations/connect').validOptions;
  * @property {number} [numberOfRetries] (**default**: 5) The number of retries for a tailable cursor
  * @property {boolean} [auto_reconnect] (**default**: true) Enable auto reconnecting for single server instances
  * @property {boolean} [monitorCommands] (**default**: false) Enable command monitoring for this client
+ * @property {string|ServerApi} [serverApi] (**default**: undefined) The server API version
  * @property {number} [minSize] If present, the connection pool will be initialized with minSize connections, and will never dip below minSize connections
  * @property {boolean} [useNewUrlParser] (**default**: true) Determines whether or not to use the new url parser. Enables the new, spec-compliant, url parser shipped in the core driver. This url parser fixes a number of problems with the original parser, and aims to outright replace that parser in the near future. Defaults to true, and must be explicitly set to false to use the legacy url parser.
  * @property {boolean} [useUnifiedTopology] Enables the new unified topology layer
@@ -191,16 +193,38 @@ const validOptions = require('./operations/connect').validOptions;
  * @param {MongoClientOptions} [options] Optional settings
  */
 function MongoClient(url, options) {
+  options = options || {};
   if (!(this instanceof MongoClient)) return new MongoClient(url, options);
   // Set up event emitter
   EventEmitter.call(this);
 
-  if (options && options.autoEncryption) require('./encrypter'); // Does CSFLE lib check
+  if (options.autoEncryption) require('./encrypter'); // Does CSFLE lib check
+
+  if (options.serverApi) {
+    const serverApiToValidate =
+      typeof options.serverApi === 'string' ? { version: options.serverApi } : options.serverApi;
+    const versionToValidate = serverApiToValidate && serverApiToValidate.version;
+    if (!versionToValidate) {
+      throw new MongoError(
+        `Invalid \`serverApi\` property; must specify a version from the following enum: ["${ValidServerApiVersions.join(
+          '", "'
+        )}"]`
+      );
+    }
+    if (!ValidServerApiVersions.some(v => v === versionToValidate)) {
+      throw new MongoError(
+        `Invalid server API version=${versionToValidate}; must be in the following enum: ["${ValidServerApiVersions.join(
+          '", "'
+        )}"]`
+      );
+    }
+    options.serverApi = serverApiToValidate;
+  }
 
   // The internal state
   this.s = {
-    url: url,
-    options: options || {},
+    url,
+    options,
     promiseLibrary: (options && options.promiseLibrary) || Promise,
     dbCache: new Map(),
     sessions: new Set(),
@@ -364,17 +388,18 @@ MongoClient.prototype.db = function(dbName, options) {
  * Check if MongoClient is connected
  *
  * @method
+ * @deprecated
  * @param {object} [options] Optional settings.
  * @param {boolean} [options.noListener=false] Do not make the db an event listener to the original connection.
  * @param {boolean} [options.returnNonCachedInstance=false] Control if you want to return a cached instance or have a new one created
  * @return {boolean}
  */
-MongoClient.prototype.isConnected = function(options) {
+MongoClient.prototype.isConnected = deprecate(function(options) {
   options = options || {};
 
   if (!this.topology) return false;
   return this.topology.isConnected(options);
-};
+}, 'isConnected is deprecated and will be removed in the next major version');
 
 /**
  * Connect to MongoDB using a url as documented at

package/lib/operations/connect.js

@@ -138,6 +138,7 @@ const validOptionNames = [
   'auto_reconnect',
   'minSize',
   'monitorCommands',
+  'serverApi',
   'retryWrites',
   'retryReads',
   'useNewUrlParser',

package/lib/operations/db_ops.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
 const applyWriteConcern = require('../utils').applyWriteConcern;
 const Code = require('../core').BSON.Code;
 const debugOptions = require('../utils').debugOptions;
@@ -75,12 +76,12 @@ function createIndex(db, name, fieldOrSpec, options, callback) {
      * 197 = 'InvalidIndexSpecificationOption' (`_id` with `background: true`)
      */
     if (
-      err.code === 67 ||
-      err.code === 11000 ||
-      err.code === 85 ||
-      err.code === 86 ||
-      err.code === 11600 ||
-      err.code === 197
+      err.code === MONGODB_ERROR_CODES.CannotCreateIndex ||
+      err.code === MONGODB_ERROR_CODES.DuplicateKey ||
+      err.code === MONGODB_ERROR_CODES.IndexOptionsConflict ||
+      err.code === MONGODB_ERROR_CODES.IndexKeySpecsConflict ||
+      err.code === MONGODB_ERROR_CODES.InterruptedAtShutdown ||
+      err.code === MONGODB_ERROR_CODES.InvalidIndexSpecificationOption
     ) {
       return handleCallback(callback, err, result);
     }
@@ -147,7 +148,9 @@ function ensureIndex(db, name, fieldOrSpec, options, callback) {
 
   // Check if the index already exists
   indexInformation(db, name, finalOptions, (err, indexInformation) => {
-    if (err != null && err.code !== 26) return handleCallback(callback, err, null);
+    if (err != null && err.code !== MONGODB_ERROR_CODES.NamespaceNotFound) {
+      return handleCallback(callback, err, null);
+    }
     // If the index does not exist, create it
     if (indexInformation == null || !indexInformation[index_name]) {
       createIndex(db, name, fieldOrSpec, options, callback);

package/lib/operations/estimated_document_count.js

@@ -1,43 +1,72 @@
 'use strict';
 
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
 const CommandOperationV2 = require('./command_v2');
+const maxWireVersion = require('../core/utils').maxWireVersion;
+const CountDocumentsOperation = require('./count_documents');
 
 class EstimatedDocumentCountOperation extends CommandOperationV2 {
-  constructor(collection, query, options) {
-    if (typeof options === 'undefined') {
-      options = query;
-      query = undefined;
-    }
-
+  constructor(collection, options) {
     super(collection, options);
+    this.collection = collection;
     this.collectionName = collection.s.namespace.collection;
-    if (query) {
-      this.query = query;
-    }
   }
 
   execute(server, callback) {
-    const options = this.options;
-    const cmd = { count: this.collectionName };
+    if (maxWireVersion(server) < 12) {
+      return this.executeLegacy(server, callback);
+    }
+    // if the user specifies a filter, use a CountDocumentsOperation instead
+    if (this.options.query) {
+      const op = new CountDocumentsOperation(this.collection, this.options.query, this.options);
+      return op.execute(server, callback);
+    }
+    const pipeline = [{ $collStats: { count: {} } }, { $group: { _id: 1, n: { $sum: '$count' } } }];
+    const cmd = { aggregate: this.collectionName, pipeline, cursor: {} };
 
-    if (this.query) {
-      cmd.query = this.query;
+    if (typeof this.options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = this.options.maxTimeMS;
     }
 
+    super.executeCommand(server, cmd, (err, response) => {
+      if (err && err.code !== MONGODB_ERROR_CODES.NamespaceNotFound) {
+        callback(err);
+        return;
+      }
+
+      callback(
+        undefined,
+        (response &&
+          response.cursor &&
+          response.cursor.firstBatch &&
+          response.cursor.firstBatch[0].n) ||
+          0
+      );
+    });
+  }
+
+  executeLegacy(server, callback) {
+    const cmd = { count: this.collectionName };
+
+    const options = this.options;
+    if (options.query) {
+      cmd.query = options.query;
+    }
+    if (options.hint) {
+      cmd.hint = options.hint;
+    }
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    }
     if (typeof options.skip === 'number') {
       cmd.skip = options.skip;
     }
-
     if (typeof options.limit === 'number') {
       cmd.limit = options.limit;
     }
 
-    if (options.hint) {
-      cmd.hint = options.hint;
-    }
-
     super.executeCommand(server, cmd, (err, response) => {
       if (err) {
         callback(err);

package/lib/topologies/native_topology.js

@@ -44,6 +44,10 @@ class NativeTopology extends Topology {
     // Translate all the options to the core types
     clonedOptions = translateOptions(clonedOptions, socketOptions);
 
+    clonedOptions.serverApi = options.serverApi;
+
+    clonedOptions.useUnifiedTopology = options.useUnifiedTopology;
+
     super(servers, clonedOptions);
   }
 

package/lib/url_parser.js

@@ -101,6 +101,9 @@ module.exports = function(url, options, callback) {
         record = record[0].join('');
         const parsedRecord = qs.parse(record);
         const items = Object.keys(parsedRecord);
+        if (Object.keys(items).some(k => k.toLowerCase() === 'loadbalanced')) {
+          return callback(new MongoParseError('Load balancer mode requires driver version 4+'));
+        }
         if (items.some(item => item !== 'authSource' && item !== 'replicaSet')) {
           return callback(
             new MongoParseError('Text record must only set `authSource` or `replicaSet`')
@@ -378,6 +381,11 @@ function parseConnectionString(url, options) {
   object.dbName = dbName || 'admin';
   // Split up all the options
   urlOptions = (query_string_part || '').split(/[&;]/);
+
+  if (urlOptions.some(k => k.toLowerCase() === 'loadbalanced')) {
+    throw new MongoParseError('Load balancer mode requires driver version 4+');
+  }
+
   // Ugh, we have to figure out which options go to which constructor manually.
   urlOptions.forEach(function(opt) {
     if (!opt) return;

package/lib/utils.js

@@ -946,6 +946,14 @@ function deepCopy(value) {
 
   return value;
 }
+/**
+ * @param {{version: string}} pkg
+ * @returns {{ major: number; minor: number; patch: number }}
+ */
+function parsePackageVersion(pkg) {
+  const versionParts = pkg.version.split('.').map(n => Number.parseInt(n, 10));
+  return { major: versionParts[0], minor: versionParts[1], patch: versionParts[2] };
+}
 
 module.exports = {
   filterOptions,
@@ -984,5 +992,6 @@ module.exports = {
   MONGODB_WARNING_CODE,
   emitWarning,
   emitWarningOnce,
-  deepCopy
+  deepCopy,
+  parsePackageVersion
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.6.10",
+  "version": "3.7.1",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [
@@ -16,6 +16,10 @@
     "driver",
     "official"
   ],
+  "author": {
+    "name": "The MongoDB NodeJS Team",
+    "email": "dbx-node@mongodb.com"
+  },
   "peerDependenciesMeta": {
     "kerberos": {
       "optional": true
@@ -83,7 +87,7 @@
     "node": ">=4"
   },
   "bugs": {
-    "url": "https://github.com/mongodb/node-mongodb-native/issues"
+    "url": "https://jira.mongodb.org/projects/NODE/issues/"
   },
   "scripts": {
     "build:evergreen": "node .evergreen/generate_evergreen_tasks.js",
@@ -98,7 +102,7 @@
     "check:tls": "mocha --opts '{}' test/manual/tls_support.test.js",
     "format": "npm run check:lint -- --fix",
     "release": "standard-version -i HISTORY.md",
-    "test": "npm run lint && mocha --recursive test/functional test/unit"
+    "test": "npm run check:lint && mocha --recursive test/functional test/unit"
   },
   "homepage": "https://github.com/mongodb/node-mongodb-native",
   "optionalDependencies": {