mongodb 3.6.4 → 3.6.8

package/lib/operations/connect.js

@@ -13,9 +13,9 @@ const ReplSet = require('../topologies/replset');
 const Server = require('../topologies/server');
 const ServerSessionPool = require('../core').Sessions.ServerSessionPool;
 const emitDeprecationWarning = require('../utils').emitDeprecationWarning;
+const emitWarningOnce = require('../utils').emitWarningOnce;
 const fs = require('fs');
 const WriteConcern = require('../write_concern');
-const BSON = require('../core/connection/utils').retrieveBSON();
 const CMAP_EVENT_NAMES = require('../cmap/events').CMAP_EVENT_NAMES;
 
 let client;
@@ -182,12 +182,12 @@ function validOptions(options) {
       if (options.validateOptions) {
         return new MongoError(`option ${name} is not supported`);
       } else {
-        console.warn(`the options [${name}] is not supported`);
+        emitWarningOnce(`the options [${name}] is not supported`);
       }
     }
 
     if (legacyOptionNames.indexOf(name) !== -1) {
-      console.warn(
+      emitWarningOnce(
         `the server/replset/mongos/db options are deprecated, ` +
           `all their options are supported at the top level of the options object [${validOptionNames}]`
       );
@@ -257,9 +257,6 @@ function resolveTLSOptions(options) {
   });
 }
 
-const emitDeprecationForNonUnifiedTopology = deprecate(() => {},
-'current Server Discovery and Monitoring engine is deprecated, and will be removed in a future version. ' + 'To use the new Server Discover and Monitoring engine, pass option { useUnifiedTopology: true } to the MongoClient constructor.');
-
 function connect(mongoClient, url, options, callback) {
   options = Object.assign({}, options);
 
@@ -335,7 +332,9 @@ function connect(mongoClient, url, options, callback) {
       return createTopology(mongoClient, 'unified', _finalOptions, connectCallback);
     }
 
-    emitDeprecationForNonUnifiedTopology();
+    emitWarningOnce(
+      'Current Server Discovery and Monitoring engine is deprecated, and will be removed in a future version. To use the new Server Discover and Monitoring engine, pass option { useUnifiedTopology: true } to the MongoClient constructor.'
+    );
 
     // Do we have a replicaset then skip discovery and go straight to connectivity
     if (_finalOptions.replicaSet || _finalOptions.rs_name) {
@@ -496,58 +495,9 @@ function createTopology(mongoClient, topologyType, options, callback) {
 
   // determine CSFLE support
   if (options.autoEncryption != null) {
-    let AutoEncrypter;
-    try {
-      require.resolve('mongodb-client-encryption');
-    } catch (err) {
-      callback(
-        new MongoError(
-          'Auto-encryption requested, but the module is not installed. Please add `mongodb-client-encryption` as a dependency of your project'
-        )
-      );
-      return;
-    }
-
-    try {
-      let mongodbClientEncryption = require('mongodb-client-encryption');
-      if (typeof mongodbClientEncryption.extension !== 'function') {
-        callback(
-          new MongoError(
-            'loaded version of `mongodb-client-encryption` does not have property `extension`. Please make sure you are loading the correct version of `mongodb-client-encryption`'
-          )
-        );
-      }
-      AutoEncrypter = mongodbClientEncryption.extension(require('../../index')).AutoEncrypter;
-    } catch (err) {
-      callback(err);
-      return;
-    }
-
-    const mongoCryptOptions = Object.assign(
-      {
-        bson:
-          options.bson ||
-          new BSON([
-            BSON.Binary,
-            BSON.Code,
-            BSON.DBRef,
-            BSON.Decimal128,
-            BSON.Double,
-            BSON.Int32,
-            BSON.Long,
-            BSON.Map,
-            BSON.MaxKey,
-            BSON.MinKey,
-            BSON.ObjectId,
-            BSON.BSONRegExp,
-            BSON.Symbol,
-            BSON.Timestamp
-          ])
-      },
-      options.autoEncryption
-    );
-
-    options.autoEncrypter = new AutoEncrypter(mongoClient, mongoCryptOptions);
+    const Encrypter = require('../encrypter').Encrypter;
+    options.encrypter = new Encrypter(mongoClient, options);
+    options.autoEncrypter = options.encrypter.autoEncrypter;
   }
 
   // Create the topology
@@ -585,7 +535,10 @@ function createTopology(mongoClient, topologyType, options, callback) {
           return;
         }
 
-        callback(undefined, topology);
+        options.encrypter.connectInternalClient(error => {
+          if (error) return callback(error);
+          callback(undefined, topology);
+        });
       });
     });
 
@@ -616,7 +569,7 @@ function createUnifiedOptions(finalOptions, options) {
     'mongos_options'
   ];
   const noMerge = ['readconcern', 'compression', 'autoencryption'];
-  const skip = ['w', 'wtimeout', 'j', 'journal', 'fsync', 'writeConcern'];
+  const skip = ['w', 'wtimeout', 'j', 'journal', 'fsync', 'writeconcern'];
 
   for (const name in options) {
     if (skip.indexOf(name.toLowerCase()) !== -1) {

package/lib/operations/execute_operation.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const maybePromise = require('../utils').maybePromise;
 const MongoError = require('../core/error').MongoError;
 const Aspect = require('./operation').Aspect;
 const OperationBase = require('./operation').OperationBase;
@@ -21,7 +22,7 @@ const isUnifiedTopology = require('../core/utils').isUnifiedTopology;
  * @param {Operation} operation The operation to execute
  * @param {function} callback The command result callback
  */
-function executeOperation(topology, operation, callback) {
+function executeOperation(topology, operation, cb) {
   if (topology == null) {
     throw new TypeError('This method requires a valid topology instance');
   }
@@ -30,64 +31,57 @@ function executeOperation(topology, operation, callback) {
     throw new TypeError('This method requires a valid operation instance');
   }
 
-  if (isUnifiedTopology(topology) && topology.shouldCheckForSessionSupport()) {
-    return selectServerForSessionSupport(topology, operation, callback);
-  }
-
-  const Promise = topology.s.promiseLibrary;
-
-  // The driver sessions spec mandates that we implicitly create sessions for operations
-  // that are not explicitly provided with a session.
-  let session, owner;
-  if (topology.hasSessionSupport()) {
-    if (operation.session == null) {
-      owner = Symbol();
-      session = topology.startSession({ owner });
-      operation.session = session;
-    } else if (operation.session.hasEnded) {
-      throw new MongoError('Use of expired sessions is not permitted');
+  return maybePromise(topology, cb, callback => {
+    if (isUnifiedTopology(topology) && topology.shouldCheckForSessionSupport()) {
+      // Recursive call to executeOperation after a server selection
+      return selectServerForSessionSupport(topology, operation, callback);
     }
-  }
-
-  let result;
-  if (typeof callback !== 'function') {
-    result = new Promise((resolve, reject) => {
-      callback = (err, res) => {
-        if (err) return reject(err);
-        resolve(res);
-      };
-    });
-  }
 
-  function executeCallback(err, result) {
-    if (session && session.owner === owner) {
-      session.endSession();
-      if (operation.session === session) {
-        operation.clearSession();
+    // The driver sessions spec mandates that we implicitly create sessions for operations
+    // that are not explicitly provided with a session.
+    let session, owner;
+    if (topology.hasSessionSupport()) {
+      if (operation.session == null) {
+        owner = Symbol();
+        session = topology.startSession({ owner });
+        operation.session = session;
+      } else if (operation.session.hasEnded) {
+        return callback(new MongoError('Use of expired sessions is not permitted'));
       }
+    } else if (operation.session) {
+      // If the user passed an explicit session and we are still, after server selection,
+      // trying to run against a topology that doesn't support sessions we error out.
+      return callback(new MongoError('Current topology does not support sessions'));
     }
 
-    callback(err, result);
-  }
-
-  try {
-    if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
-      executeWithServerSelection(topology, operation, executeCallback);
-    } else {
-      operation.execute(executeCallback);
-    }
-  } catch (e) {
-    if (session && session.owner === owner) {
-      session.endSession();
-      if (operation.session === session) {
-        operation.clearSession();
+    function executeCallback(err, result) {
+      if (session && session.owner === owner) {
+        session.endSession();
+        if (operation.session === session) {
+          operation.clearSession();
+        }
       }
+
+      callback(err, result);
     }
 
-    throw e;
-  }
+    try {
+      if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
+        executeWithServerSelection(topology, operation, executeCallback);
+      } else {
+        operation.execute(executeCallback);
+      }
+    } catch (error) {
+      if (session && session.owner === owner) {
+        session.endSession();
+        if (operation.session === session) {
+          operation.clearSession();
+        }
+      }
 
-  return result;
+      callback(error);
+    }
+  });
 }
 
 function supportsRetryableReads(server) {
@@ -139,7 +133,6 @@ function executeWithServerSelection(topology, operation, callback) {
       callback(err, null);
       return;
     }
-
     const shouldRetryReads =
       topology.s.options.retryReads !== false &&
       operation.session &&
@@ -156,31 +149,16 @@ function executeWithServerSelection(topology, operation, callback) {
   });
 }
 
-// TODO: This is only supported for unified topology, it should go away once
-//       we remove support for legacy topology types.
+// The Unified Topology runs serverSelection before executing every operation
+// Session support is determined by the result of a monitoring check triggered by this selection
 function selectServerForSessionSupport(topology, operation, callback) {
-  const Promise = topology.s.promiseLibrary;
-
-  let result;
-  if (typeof callback !== 'function') {
-    result = new Promise((resolve, reject) => {
-      callback = (err, result) => {
-        if (err) return reject(err);
-        resolve(result);
-      };
-    });
-  }
-
   topology.selectServer(ReadPreference.primaryPreferred, err => {
     if (err) {
-      callback(err);
-      return;
+      return callback(err);
     }
 
     executeOperation(topology, operation, callback);
   });
-
-  return result;
 }
 
 module.exports = executeOperation;

package/lib/operations/find.js

@@ -20,6 +20,9 @@ class FindOperation extends OperationBase {
     // copied from `CommandOperationV2`, to be subclassed in the future
     this.server = server;
 
+    // updates readPreference if setReadPreference was called on the cursor
+    this.readPreference = ReadPreference.resolve(this, this.options);
+
     if (typeof this.cmd.allowDiskUse !== 'undefined' && maxWireVersion(server) < 4) {
       callback(new MongoError('The `allowDiskUse` option is not supported on MongoDB < 3.2'));
       return;

package/lib/operations/find_one_and_replace.js

@@ -1,16 +1,22 @@
 'use strict';
 
+const MongoError = require('../core').MongoError;
 const FindAndModifyOperation = require('./find_and_modify');
 const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class FindOneAndReplaceOperation extends FindAndModifyOperation {
   constructor(collection, filter, replacement, options) {
+    if ('returnDocument' in options && 'returnOriginal' in options) {
+      throw new MongoError(
+        'findOneAndReplace option returnOriginal is deprecated in favor of returnDocument and cannot be combined'
+      );
+    }
     // Final options
     const finalOptions = Object.assign({}, options);
     finalOptions.fields = options.projection;
     finalOptions.update = true;
-    finalOptions.new = options.returnOriginal !== void 0 ? !options.returnOriginal : false;
-    finalOptions.upsert = options.upsert !== void 0 ? !!options.upsert : false;
+    finalOptions.new = options.returnDocument === 'after' || options.returnOriginal === false;
+    finalOptions.upsert = options.upsert === true;
 
     if (filter == null || typeof filter !== 'object') {
       throw new TypeError('Filter parameter must be an object');

package/lib/operations/find_one_and_update.js

@@ -1,17 +1,22 @@
 'use strict';
 
+const MongoError = require('../core').MongoError;
 const FindAndModifyOperation = require('./find_and_modify');
 const hasAtomicOperators = require('../utils').hasAtomicOperators;
 
 class FindOneAndUpdateOperation extends FindAndModifyOperation {
   constructor(collection, filter, update, options) {
+    if ('returnDocument' in options && 'returnOriginal' in options) {
+      throw new MongoError(
+        'findOneAndUpdate option returnOriginal is deprecated in favor of returnDocument and cannot be combined'
+      );
+    }
     // Final options
     const finalOptions = Object.assign({}, options);
     finalOptions.fields = options.projection;
     finalOptions.update = true;
-    finalOptions.new =
-      typeof options.returnOriginal === 'boolean' ? !options.returnOriginal : false;
-    finalOptions.upsert = typeof options.upsert === 'boolean' ? options.upsert : false;
+    finalOptions.new = options.returnDocument === 'after' || options.returnOriginal === false;
+    finalOptions.upsert = options.upsert === true;
 
     if (filter == null || typeof filter !== 'object') {
       throw new TypeError('Filter parameter must be an object');

package/lib/operations/insert_many.js

@@ -30,11 +30,7 @@ class InsertManyOperation extends OperationBase {
     docs = prepareDocs(coll, docs, options);
 
     // Generate the bulk write operations
-    const operations = [
-      {
-        insertMany: docs
-      }
-    ];
+    const operations = docs.map(document => ({ insertOne: { document } }));
 
     const bulkWriteOperation = new BulkWriteOperation(coll, operations, options);
 

package/lib/operations/operation.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const Explain = require('../explain').Explain;
-const MongoError = require('../core').MongoError;
+const MongoError = require('../core/error').MongoError;
 
 const Aspect = {
   READ_OPERATION: Symbol('READ_OPERATION'),

package/lib/utils.js

@@ -40,7 +40,7 @@ var formatSortValue = (exports.formatSortValue = function(sortDirection) {
 });
 
 var formattedOrderClause = (exports.formattedOrderClause = function(sortValue) {
-  var orderBy = {};
+  var orderBy = new Map();
   if (sortValue == null) return null;
   if (Array.isArray(sortValue)) {
     if (sortValue.length === 0) {
@@ -49,15 +49,22 @@ var formattedOrderClause = (exports.formattedOrderClause = function(sortValue) {
 
     for (var i = 0; i < sortValue.length; i++) {
       if (sortValue[i].constructor === String) {
-        orderBy[sortValue[i]] = 1;
+        orderBy.set(`${sortValue[i]}`, 1);
       } else {
-        orderBy[sortValue[i][0]] = formatSortValue(sortValue[i][1]);
+        orderBy.set(`${sortValue[i][0]}`, formatSortValue(sortValue[i][1]));
       }
     }
   } else if (sortValue != null && typeof sortValue === 'object') {
-    orderBy = sortValue;
+    if (sortValue instanceof Map) {
+      orderBy = sortValue;
+    } else {
+      var sortKeys = Object.keys(sortValue);
+      for (var k of sortKeys) {
+        orderBy.set(k, sortValue[k]);
+      }
+    }
   } else if (typeof sortValue === 'string') {
-    orderBy[sortValue] = 1;
+    orderBy.set(`${sortValue}`, 1);
   } else {
     throw new Error(
       'Illegal sort clause, must be of the form ' +
@@ -287,39 +294,38 @@ var filterOptions = function(options, names) {
 };
 
 // Write concern keys
-var writeConcernKeys = ['w', 'j', 'wtimeout', 'fsync'];
-
-// Merge the write concern options
-var mergeOptionsAndWriteConcern = function(targetOptions, sourceOptions, keys, mergeWriteConcern) {
-  // Mix in any allowed options
-  for (var i = 0; i < keys.length; i++) {
-    if (!targetOptions[keys[i]] && sourceOptions[keys[i]] !== undefined) {
-      targetOptions[keys[i]] = sourceOptions[keys[i]];
-    }
-  }
-
-  // No merging of write concern
-  if (!mergeWriteConcern) return targetOptions;
+const WRITE_CONCERN_KEYS = ['w', 'j', 'wtimeout', 'fsync', 'writeConcern'];
 
-  // Found no write Concern options
-  var found = false;
-  for (i = 0; i < writeConcernKeys.length; i++) {
-    if (targetOptions[writeConcernKeys[i]]) {
+/**
+ * If there is no WriteConcern related options defined on target then inherit from source.
+ * Otherwise, do not inherit **any** options from source.
+ * @internal
+ * @param {object} target - options object conditionally receiving the writeConcern options
+ * @param {object} source - options object containing the potentially inherited writeConcern options
+ */
+function conditionallyMergeWriteConcern(target, source) {
+  let found = false;
+  for (const wcKey of WRITE_CONCERN_KEYS) {
+    if (wcKey in target) {
+      // Found a writeConcern option
       found = true;
       break;
     }
   }
 
   if (!found) {
-    for (i = 0; i < writeConcernKeys.length; i++) {
-      if (sourceOptions[writeConcernKeys[i]]) {
-        targetOptions[writeConcernKeys[i]] = sourceOptions[writeConcernKeys[i]];
+    for (const wcKey of WRITE_CONCERN_KEYS) {
+      if (source[wcKey]) {
+        if (!('writeConcern' in target)) {
+          target.writeConcern = {};
+        }
+        target.writeConcern[wcKey] = source[wcKey];
       }
     }
   }
 
-  return targetOptions;
-};
+  return target;
+}
 
 /**
  * Executes the given operation with provided arguments.
@@ -534,7 +540,12 @@ function decorateWithExplain(command, explain) {
   return { explain: command, verbosity: explain.verbosity };
 }
 
-const emitProcessWarning = msg => process.emitWarning(msg, 'DeprecationWarning');
+const nodejsMajorVersion = +process.version.split('.')[0].substring(1);
+const emitProcessWarning = msg =>
+  nodejsMajorVersion <= 6
+    ? process.emitWarning(msg, 'DeprecationWarning', MONGODB_WARNING_CODE)
+    : process.emitWarning(msg, { type: 'DeprecationWarning', code: MONGODB_WARNING_CODE });
+// eslint-disable-next-line no-console
 const emitConsoleWarning = msg => console.error(msg);
 const emitDeprecationWarning = process.emitWarning ? emitProcessWarning : emitConsoleWarning;
 
@@ -816,6 +827,50 @@ function hasAtomicOperators(doc) {
   );
 }
 
+/**
+ * When the driver used emitWarning the code will be equal to this.
+ * @public
+ *
+ * @example
+ * ```js
+ * process.on('warning', (warning) => {
+ *  if (warning.code === MONGODB_WARNING_CODE) console.error('Ah an important warning! :)')
+ * })
+ * ```
+ */
+const MONGODB_WARNING_CODE = 'MONGODB DRIVER';
+
+/**
+ * @internal
+ * @param {string} message - message to warn about
+ */
+function emitWarning(message) {
+  if (process.emitWarning) {
+    return nodejsMajorVersion <= 6
+      ? process.emitWarning(message, undefined, MONGODB_WARNING_CODE)
+      : process.emitWarning(message, { code: MONGODB_WARNING_CODE });
+  } else {
+    // Approximate the style of print out on node versions pre 8.x
+    // eslint-disable-next-line no-console
+    return console.error(`[${MONGODB_WARNING_CODE}] Warning:`, message);
+  }
+}
+
+const emittedWarnings = new Set();
+/**
+ * Will emit a warning once for the duration of the application.
+ * Uses the message to identify if it has already been emitted
+ * so using string interpolation can cause multiple emits
+ * @internal
+ * @param {string} message - message to warn about
+ */
+function emitWarningOnce(message) {
+  if (!emittedWarnings.has(message)) {
+    emittedWarnings.add(message);
+    return emitWarning(message);
+  }
+}
+
 module.exports = {
   filterOptions,
   mergeOptions,
@@ -832,7 +887,7 @@ module.exports = {
   isObject,
   debugOptions,
   MAX_JS_INT: Number.MAX_SAFE_INTEGER + 1,
-  mergeOptionsAndWriteConcern,
+  conditionallyMergeWriteConcern,
   executeLegacyOperation,
   applyRetryableWrites,
   applyWriteConcern,
@@ -849,5 +904,8 @@ module.exports = {
   now,
   calculateDurationInMs,
   makeInterruptableAsyncInterval,
-  hasAtomicOperators
+  hasAtomicOperators,
+  MONGODB_WARNING_CODE,
+  emitWarning,
+  emitWarningOnce
 };

package/lib/write_concern.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const kWriteConcernKeys = new Set(['w', 'wtimeout', 'j', 'journal', 'fsync']);
+let utils;
 
 /**
  * The **WriteConcern** class is a class that represents a MongoDB WriteConcern.
@@ -75,7 +76,10 @@ class WriteConcern {
       );
     }
 
-    console.warn(
+    // this is down here to prevent circular dependency
+    if (!utils) utils = require('./utils');
+
+    utils.emitWarningOnce(
       `Top-level use of w, wtimeout, j, and fsync is deprecated. Use writeConcern instead.`
     );
     return new WriteConcern(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.6.4",
+  "version": "3.6.8",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [
@@ -16,13 +16,6 @@
     "driver",
     "official"
   ],
-  "peerOptionalDependencies": {
-    "kerberos": "^1.1.0",
-    "mongodb-client-encryption": "^1.0.0",
-    "mongodb-extjson": "^2.1.2",
-    "snappy": "^6.3.4",
-    "bson-ext": "^2.0.0"
-  },
   "peerDependenciesMeta": {
     "kerberos": {
       "optional": true
@@ -47,33 +40,39 @@
     "bl": "^2.2.1",
     "bson": "^1.1.4",
     "denque": "^1.4.1",
-    "require_optional": "^1.0.1",
+    "optional-require": "^1.0.3",
     "safe-buffer": "^5.1.2"
   },
   "devDependencies": {
+    "@types/chai": "^4.2.16",
+    "@types/mocha": "^8.2.2",
+    "@types/node": "^14.14.37",
+    "array-includes": "^3.1.3",
     "chai": "^4.1.1",
     "chai-subset": "^1.6.0",
     "chalk": "^2.4.2",
     "co": "4.6.0",
-    "coveralls": "^2.11.6",
     "eslint": "^7.10.0",
     "eslint-config-prettier": "^6.11.0",
     "eslint-plugin-es": "^3.0.1",
     "eslint-plugin-prettier": "^3.1.3",
-    "istanbul": "^0.4.5",
-    "jsdoc": "3.5.5",
+    "jsdoc": "^3.5.5",
     "lodash.camelcase": "^4.3.0",
     "mocha": "5.2.0",
     "mocha-sinon": "^2.1.0",
     "mongodb-extjson": "^2.1.1",
     "mongodb-mock-server": "^1.0.1",
+    "nyc": "^15.1.0",
+    "object.entries": "^1.1.3",
     "prettier": "^1.19.1",
     "semver": "^5.5.0",
     "sinon": "^4.3.0",
     "sinon-chai": "^3.2.0",
     "snappy": "^6.3.4",
     "spec-xunit-file": "0.0.1-3",
-    "standard-version": "^8.0.2",
+    "standard-version": "^9.2.0",
+    "tslib": "^2.2.0",
+    "typescript": "^4.2.4",
     "util.promisify": "^1.0.1",
     "worker-farm": "^1.5.0",
     "wtfnode": "^0.8.0",
@@ -87,18 +86,19 @@
     "url": "https://github.com/mongodb/node-mongodb-native/issues"
   },
   "scripts": {
-    "atlas": "mocha --opts '{}' ./test/manual/atlas_connectivity.test.js",
+    "build:evergreen": "node .evergreen/generate_evergreen_tasks.js",
+    "build:unified": "tsc -p test/functional/unified-spec-runner/tsconfig.unified.json",
+    "check:atlas": "mocha --opts '{}' ./test/manual/atlas_connectivity.test.js",
+    "check:bench": "node test/benchmarks/driverBench/",
+    "check:coverage": "nyc npm run check:test",
     "check:kerberos": "mocha --opts '{}' -t 60000 test/manual/kerberos.test.js",
     "check:ldap": "mocha --opts '{}' test/manual/ldap.test.js",
+    "check:lint": "eslint -v && eslint lib test",
+    "check:test": "mocha --recursive test/functional test/unit",
     "check:tls": "mocha --opts '{}' test/manual/tls_support.test.js",
-    "test": "npm run lint && mocha --recursive test/functional test/unit",
-    "test-nolint": "mocha --recursive test/functional test/unit",
-    "coverage": "istanbul cover mongodb-test-runner -- -t 60000 test/unit test/functional",
-    "lint": "eslint -v && eslint lib test",
-    "format": "npm run lint -- --fix",
-    "bench": "node test/benchmarks/driverBench/",
-    "generate-evergreen": "node .evergreen/generate_evergreen_tasks.js",
-    "release": "standard-version -i HISTORY.md"
+    "format": "npm run check:lint -- --fix",
+    "release": "standard-version -i HISTORY.md",
+    "test": "npm run lint && mocha --recursive test/functional test/unit"
   },
   "homepage": "https://github.com/mongodb/node-mongodb-native",
   "optionalDependencies": {