mongodb 3.3.0-beta1 → 3.3.2

package/lib/db.js

@@ -22,16 +22,16 @@ const MongoDBNamespace = require('./utils').MongoDBNamespace;
 const CONSTANTS = require('./constants');
 const WriteConcern = require('./write_concern');
 const ReadConcern = require('./read_concern');
+const AggregationCursor = require('./aggregation_cursor');
 
 // Operations
-const aggregate = require('./operations/aggregate').aggregate;
 const createListener = require('./operations/db_ops').createListener;
 const ensureIndex = require('./operations/db_ops').ensureIndex;
 const evaluate = require('./operations/db_ops').evaluate;
-const listCollectionsTransforms = require('./operations/db_ops').listCollectionsTransforms;
 const profilingInfo = require('./operations/db_ops').profilingInfo;
 const validateDatabaseName = require('./operations/db_ops').validateDatabaseName;
 
+const AggregateOperation = require('./operations/aggregate');
 const AddUserOperation = require('./operations/add_user');
 const CollectionsOperation = require('./operations/collections');
 const CommandOperation = require('./operations/command');
@@ -41,6 +41,7 @@ const DropCollectionOperation = require('./operations/drop').DropCollectionOpera
 const DropDatabaseOperation = require('./operations/drop').DropDatabaseOperation;
 const ExecuteDbAdminCommandOperation = require('./operations/execute_db_admin_command');
 const IndexInformationOperation = require('./operations/index_information');
+const ListCollectionsOperation = require('./operations/list_collections');
 const ProfilingLevelOperation = require('./operations/profiling_level');
 const RemoveUserOperation = require('./operations/remove_user');
 const RenameOperation = require('./operations/rename');
@@ -329,7 +330,19 @@ Db.prototype.aggregate = function(pipeline, options, callback) {
     options = {};
   }
 
-  return aggregate(this, '1', pipeline, options, callback);
+  const cursor = new AggregationCursor(
+    this.s.topology,
+    new AggregateOperation(this, pipeline, options),
+    options
+  );
+
+  // TODO: remove this when NODE-2074 is resolved
+  if (typeof callback === 'function') {
+    callback(null, cursor);
+    return;
+  }
+
+  return cursor;
 };
 
 /**
@@ -489,7 +502,7 @@ Db.prototype.collection = function(name, options, callback) {
  * @param {string} [options.validationAction] Determines whether to error on invalid documents or just warn about the violations but allow invalid documents to be inserted on MongoDB 3.2 or higher.
  * @param {object} [options.indexOptionDefaults] Allows users to specify a default configuration for indexes when creating a collection on MongoDB 3.2 or higher.
  * @param {string} [options.viewOn] The name of the source collection or view from which to create the view. The name is not the full namespace of the collection or view; i.e. does not include the database name and implies the same database as the view to create on MongoDB 3.4 or higher.
- * @param {array} [options.pipeline] An array that consists of the aggregation pipeline stage. create creates the view by applying the specified pipeline to the viewOn collection or view on MongoDB 3.4 or higher.
+ * @param {array} [options.pipeline] An array that consists of the aggregation pipeline stage. Creates the view by applying the specified pipeline to the viewOn collection or view on MongoDB 3.4 or higher.
  * @param {object} [options.collation] Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).
  * @param {ClientSession} [options.session] optional session to use for this operation
  * @param {Db~collectionResultCallback} [callback] The results callback
@@ -505,7 +518,9 @@ Db.prototype.createCollection = deprecateOptions(
     if (typeof options === 'function') (callback = options), (options = {});
     options = options || {};
     options.promiseLibrary = options.promiseLibrary || this.s.promiseLibrary;
-
+    options.readConcern = options.readConcern
+      ? new ReadConcern(options.readConcern.level)
+      : this.readConcern;
     const createCollectionOperation = new CreateCollectionOperation(this, name, options);
 
     return executeOperation(this.s.topology, createCollectionOperation, callback);
@@ -557,72 +572,11 @@ Db.prototype.listCollections = function(filter, options) {
   filter = filter || {};
   options = options || {};
 
-  // Shallow clone the object
-  options = Object.assign({}, options);
-  // Set the promise library
-  options.promiseLibrary = this.s.promiseLibrary;
-
-  // Ensure valid readPreference
-  options.readPreference = resolveReadPreference(this, options);
-
-  // Cursor options
-  let cursor = options.batchSize ? { batchSize: options.batchSize } : {};
-
-  // We have a list collections command
-  if (this.serverConfig.capabilities().hasListCollectionsCommand) {
-    const nameOnly = typeof options.nameOnly === 'boolean' ? options.nameOnly : false;
-    // Build the command
-    const command = { listCollections: true, filter, cursor, nameOnly };
-    // Set the AggregationCursor constructor
-    options.cursorFactory = CommandCursor;
-    // Create the cursor
-    cursor = this.s.topology.cursor(
-      this.s.namespace.withCollection('$cmd').toString(),
-      command,
-      options
-    );
-    // Do we have a readPreference, apply it
-    if (options.readPreference) {
-      cursor.setReadPreference(options.readPreference);
-    }
-    // Return the cursor
-    return cursor;
-  }
-
-  // We cannot use the listCollectionsCommand
-  if (!this.serverConfig.capabilities().hasListCollectionsCommand) {
-    // If we have legacy mode and have not provided a full db name filter it
-    if (
-      typeof filter.name === 'string' &&
-      !new RegExp('^' + this.databaseName + '\\.').test(filter.name)
-    ) {
-      filter = Object.assign({}, filter);
-      filter.name = this.s.namespace.withCollection(filter.name).toString();
-    }
-  }
-
-  // No filter, filter by current database
-  if (filter == null) {
-    filter.name = `/${this.databaseName}/`;
-  }
-
-  // Rewrite the filter to use $and to filter out indexes
-  if (filter.name) {
-    filter = { $and: [{ name: filter.name }, { name: /^((?!\$).)*$/ }] };
-  } else {
-    filter = { name: /^((?!\$).)*$/ };
-  }
-
-  // Return options
-  const _options = { transforms: listCollectionsTransforms(this.databaseName) };
-  // Get the cursor
-  cursor = this.collection(CONSTANTS.SYSTEM_NAMESPACE_COLLECTION).find(filter, _options);
-  // Do we have a readPreference, apply it
-  if (options.readPreference) cursor.setReadPreference(options.readPreference);
-  // Set the passed in batch size if one was provided
-  if (options.batchSize) cursor = cursor.batchSize(options.batchSize);
-  // We have a fallback mode using legacy systems collections
-  return cursor;
+  return new CommandCursor(
+    this.s.topology,
+    new ListCollectionsOperation(this, filter, options),
+    options
+  );
 };
 
 /**
@@ -687,6 +641,10 @@ Db.prototype.renameCollection = function(fromCollection, toCollection, options,
  * @method
  * @param {string} name Name of collection to drop
  * @param {Object} [options] Optional settings
+ * @param {WriteConcern} [options.writeConcern] A full WriteConcern object
+ * @param {(number|string)} [options.w] The write concern
+ * @param {number} [options.wtimeout] The write concern timeout
+ * @param {boolean} [options.j] The journal write concern
  * @param {ClientSession} [options.session] optional session to use for this operation
  * @param {Db~resultCallback} [callback] The results callback
  * @return {Promise} returns Promise if no callback passed
@@ -777,7 +735,7 @@ Db.prototype.executeDbAdminCommand = function(selector, options, callback) {
  * @param {number} [options.max] For geospatial indexes set the high bound for the co-ordinates.
  * @param {number} [options.v] Specify the format version of the indexes.
  * @param {number} [options.expireAfterSeconds] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
- * @param {number} [options.name] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
+ * @param {string} [options.name] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
  * @param {object} [options.partialFilterExpression] Creates a partial index based on the given filter object (MongoDB 3.2 or higher)
  * @param {ClientSession} [options.session] optional session to use for this operation
  * @param {Db~resultCallback} [callback] The command result callback
@@ -975,7 +933,7 @@ Db.prototype.unref = function() {
  * @param {number} [options.batchSize] The number of documents to return per batch. See {@link https://docs.mongodb.com/manual/reference/command/aggregate|aggregation documentation}.
  * @param {object} [options.collation] Specify collation settings for operation. See {@link https://docs.mongodb.com/manual/reference/command/aggregate|aggregation documentation}.
  * @param {ReadPreference} [options.readPreference] The read preference. Defaults to the read preference of the database. See {@link https://docs.mongodb.com/manual/reference/read-preference|read preference documentation}.
- * @param {Timestamp} [options.startAtClusterTime] receive change events that occur after the specified timestamp
+ * @param {Timestamp} [options.startAtOperationTime] receive change events that occur after the specified timestamp
  * @param {ClientSession} [options.session] optional session to use for this operation
  * @return {ChangeStream} a ChangeStream instance.
  */

package/lib/error.js

@@ -9,15 +9,15 @@ const GET_MORE_NON_RESUMABLE_CODES = new Set([
   11601 // Interrupted
 ]);
 
-// From spec@https://github.com/mongodb/specifications/blob/35e466ddf25059cb30e4113de71cdebd3754657f/source/change-streams.rst#resumable-error:
+// From spec@https://github.com/mongodb/specifications/blob/7a2e93d85935ee4b1046a8d2ad3514c657dc74fa/source/change-streams/change-streams.rst#resumable-error:
 //
 // An error is considered resumable if it meets any of the following criteria:
 // - any error encountered which is not a server error (e.g. a timeout error or network error)
-// - any server error response from a getMore command excluding those containing the following error codes
+// - any server error response from a getMore command excluding those containing the error label
+//   NonRetryableChangeStreamError and those containing the following error codes:
 //   - Interrupted: 11601
 //   - CappedPositionLost: 136
 //   - CursorKilled: 237
-// - a server error response with an error message containing the substring "not master" or "node is recovering"
 //
 // An error on an aggregate command is not a resumable error. Only errors on a getMore command may be considered resumable errors.
 
@@ -32,11 +32,13 @@ function isResumableError(error) {
     return false;
   }
 
-  return !!(
-    error instanceof MongoNetworkError ||
-    !GET_MORE_NON_RESUMABLE_CODES.has(error.code) ||
-    error.message.match(/not master/) ||
-    error.message.match(/node is recovering/)
+  if (error instanceof MongoNetworkError) {
+    return true;
+  }
+
+  return !(
+    GET_MORE_NON_RESUMABLE_CODES.has(error.code) ||
+    error.hasErrorLabel('NonRetryableChangeStreamError')
   );
 }
 

package/lib/gridfs-stream/download.js

@@ -185,12 +185,19 @@ function doRead(_this) {
     }
     if (!doc) {
       _this.push(null);
-      return _this.s.cursor.close(function(error) {
-        if (error) {
-          return __handleError(_this, error);
-        }
-        _this.emit('close');
+
+      process.nextTick(() => {
+        _this.s.cursor.close(function(error) {
+          if (error) {
+            __handleError(_this, error);
+            return;
+          }
+
+          _this.emit('close');
+        });
       });
+
+      return;
     }
 
     var bytesRemaining = _this.s.file.length - _this.s.bytesRead;

package/lib/mongo_client.js

@@ -3,16 +3,17 @@
 const ChangeStream = require('./change_stream');
 const Db = require('./db');
 const EventEmitter = require('events').EventEmitter;
-const executeLegacyOperation = require('./utils').executeLegacyOperation;
+const executeOperation = require('./operations/execute_operation');
 const inherits = require('util').inherits;
 const MongoError = require('./core').MongoError;
 const deprecate = require('util').deprecate;
 const WriteConcern = require('./write_concern');
+const MongoDBNamespace = require('./utils').MongoDBNamespace;
+const ReadPreference = require('./core/topologies/read_preference');
 
 // Operations
-const connectOp = require('./operations/mongo_client_ops').connectOp;
-const validOptions = require('./operations/mongo_client_ops').validOptions;
-const closeOperation = require('./operations/mongo_client_ops').closeOperation;
+const ConnectOperation = require('./operations/connect');
+const CloseOperation = require('./operations/close');
 
 /**
  * @fileOverview The **MongoClient** class is a class that allows for making Connections to MongoDB.
@@ -54,7 +55,9 @@ const closeOperation = require('./operations/mongo_client_ops').closeOperation;
  */
 
 /**
- * Configuration options for a automatic client encryption
+ * Configuration options for a automatic client encryption.
+ *
+ * **NOTE**: Support for client side encryption is in beta. Backwards-breaking changes may be made before the final release.
  *
  * @typedef {Object} AutoEncryptionOptions
  * @property {MongoClient} [keyVaultClient] A `MongoClient` used to fetch keys from a key vault
@@ -67,6 +70,11 @@ const closeOperation = require('./operations/mongo_client_ops').closeOperation;
  * @property {string} [kmsProviders.local.key] The master key used to encrypt/decrypt data keys
  * @property {object} [schemaMap] A map of namespaces to a local JSON schema for encryption
  * @property {boolean} [bypassAutoEncryption] Allows the user to bypass auto encryption, maintaining implicit decryption
+ * @property {object} [extraOptions] Extra options related to the mongocryptd process
+ * @property {string} [extraOptions.mongocryptURI] A local process the driver communicates with to determine how to encrypt values in a command. Defaults to "mongodb://%2Fvar%2Fmongocryptd.sock" if domain sockets are available or "mongodb://localhost:27020" otherwise
+ * @property {boolean} [extraOptions.mongocryptdBypassSpawn=false] If true, autoEncryption will not attempt to spawn a mongocryptd before connecting
+ * @property {string} [extraOptions.mongocryptdSpawnPath] The path to the mongocryptd executable on the system
+ * @property {string[]} [extraOptions.mongocryptdSpawnArgs] Command line arguments to use when auto-spawning a mongocryptd
  */
 
 /**
@@ -148,9 +156,10 @@ function MongoClient(url, options) {
     url: url,
     options: options || {},
     promiseLibrary: null,
-    dbCache: {},
-    sessions: [],
-    writeConcern: WriteConcern.fromOptions(options)
+    dbCache: new Map(),
+    sessions: new Set(),
+    writeConcern: WriteConcern.fromOptions(options),
+    namespace: new MongoDBNamespace('admin')
   };
 
   // Get the promiseLibrary
@@ -172,6 +181,13 @@ Object.defineProperty(MongoClient.prototype, 'writeConcern', {
   }
 });
 
+Object.defineProperty(MongoClient.prototype, 'readPreference', {
+  enumerable: true,
+  get: function() {
+    return ReadPreference.primary;
+  }
+});
+
 /**
  * The callback format for results
  * @callback MongoClient~connectCallback
@@ -191,16 +207,13 @@ Object.defineProperty(MongoClient.prototype, 'writeConcern', {
  * @return {Promise<MongoClient>} returns Promise if no callback passed
  */
 MongoClient.prototype.connect = function(callback) {
-  // Validate options object
-  const err = validOptions(this.s.options);
-
   if (typeof callback === 'string') {
     throw new TypeError('`connect` only accepts a callback');
   }
 
-  return executeLegacyOperation(this, connectOp, [this, err, callback], {
-    skipSessions: true
-  });
+  const operation = new ConnectOperation(this);
+
+  return executeOperation(this, operation, callback);
 };
 
 MongoClient.prototype.logout = deprecate(function(options, callback) {
@@ -217,9 +230,8 @@ MongoClient.prototype.logout = deprecate(function(options, callback) {
  */
 MongoClient.prototype.close = function(force, callback) {
   if (typeof force === 'function') (callback = force), (force = false);
-  return executeLegacyOperation(this, closeOperation, [this, force, callback], {
-    skipSessions: true
-  });
+  const operation = new CloseOperation(this, force);
+  return executeOperation(this, operation, callback);
 };
 
 /**
@@ -247,8 +259,8 @@ MongoClient.prototype.db = function(dbName, options) {
   const finalOptions = Object.assign({}, this.s.options, options);
 
   // Do we have the db in the cache already
-  if (this.s.dbCache[dbName] && finalOptions.returnNonCachedInstance !== true) {
-    return this.s.dbCache[dbName];
+  if (this.s.dbCache.has(dbName) && finalOptions.returnNonCachedInstance !== true) {
+    return this.s.dbCache.get(dbName);
   }
 
   // Add promiseLibrary
@@ -263,7 +275,7 @@ MongoClient.prototype.db = function(dbName, options) {
   const db = new Db(dbName, this.topology, finalOptions);
 
   // Add the db to the cache
-  this.s.dbCache[dbName] = db;
+  this.s.dbCache.set(dbName, db);
   // Return the database
   return db;
 };
@@ -437,7 +449,7 @@ MongoClient.prototype.withSession = function(options, operation) {
  * @param {number} [options.batchSize] The number of documents to return per batch. See {@link https://docs.mongodb.com/manual/reference/command/aggregate|aggregation documentation}.
  * @param {object} [options.collation] Specify collation settings for operation. See {@link https://docs.mongodb.com/manual/reference/command/aggregate|aggregation documentation}.
  * @param {ReadPreference} [options.readPreference] The read preference. See {@link https://docs.mongodb.com/manual/reference/read-preference|read preference documentation}.
- * @param {Timestamp} [options.startAtClusterTime] receive change events that occur after the specified timestamp
+ * @param {Timestamp} [options.startAtOperationTime] receive change events that occur after the specified timestamp
  * @param {ClientSession} [options.session] optional session to use for this operation
  * @return {ChangeStream} a ChangeStream instance.
  */

package/lib/operations/aggregate.js

@@ -1,124 +1,106 @@
 'use strict';
 
-const AggregationCursor = require('../aggregation_cursor');
-const applyWriteConcern = require('../utils').applyWriteConcern;
-const decorateWithCollation = require('../utils').decorateWithCollation;
-const decorateWithReadConcern = require('../utils').decorateWithReadConcern;
-const handleCallback = require('../utils').handleCallback;
+const CommandOperationV2 = require('./command_v2');
 const MongoError = require('../core').MongoError;
-const resolveReadPreference = require('../utils').resolveReadPreference;
-const toError = require('../utils').toError;
+const maxWireVersion = require('../core/utils').maxWireVersion;
+const ReadPreference = require('../core').ReadPreference;
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
 
 const DB_AGGREGATE_COLLECTION = 1;
-
 const MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT = 8;
 
-/**
- * Perform an aggregate operation. See Collection.prototype.aggregate or Db.prototype.aggregate for more information.
- *
- * @method
- * @param {Db} db A Db instance.
- * @param {Collection|string} coll A collection instance or the string '1', used for db.aggregate.
- * @param {object} [pipeline=[]] Array containing all the aggregation framework commands for the execution.
- * @param {object} [options] Optional settings. See Collection.prototype.aggregate or Db.prototype.aggregate for a list of options.
- * @param {Db~aggregationCallback|Collection~aggregationCallback} callback The command result callback
- */
-function aggregate(db, coll, pipeline, options, callback) {
-  const isDbAggregate = typeof coll === 'string';
-  const target = isDbAggregate ? db : coll;
-  const topology = target.s.topology;
-  let hasOutStage = false;
-
-  if (typeof options.out === 'string') {
-    pipeline = pipeline.concat({ $out: options.out });
-    hasOutStage = true;
-  } else if (pipeline.length > 0 && pipeline[pipeline.length - 1]['$out']) {
-    hasOutStage = true;
-  }
-
-  let command;
-  let namespace;
-  let optionSources;
-
-  if (isDbAggregate) {
-    command = { aggregate: DB_AGGREGATE_COLLECTION, pipeline: pipeline };
-    namespace = db.s.namespace.withCollection(DB_AGGREGATE_COLLECTION);
-
-    optionSources = { db };
-  } else {
-    command = { aggregate: coll.collectionName, pipeline: pipeline };
-    namespace = coll.s.namespace;
-
-    optionSources = { db: coll.s.db, collection: coll };
-  }
+class AggregateOperation extends CommandOperationV2 {
+  constructor(parent, pipeline, options) {
+    super(parent, options, { fullResponse: true });
+
+    this.target =
+      parent.s.namespace && parent.s.namespace.collection
+        ? parent.s.namespace.collection
+        : DB_AGGREGATE_COLLECTION;
+
+    this.pipeline = pipeline;
+
+    // determine if we have a write stage, override read preference if so
+    this.hasWriteStage = false;
+    if (typeof options.out === 'string') {
+      this.pipeline = this.pipeline.concat({ $out: options.out });
+      this.hasWriteStage = true;
+    } else if (pipeline.length > 0) {
+      const finalStage = pipeline[pipeline.length - 1];
+      if (finalStage.$out || finalStage.$merge) {
+        this.hasWriteStage = true;
+      }
+    }
 
-  const takesWriteConcern = topology.capabilities().commandsTakeWriteConcern;
-  const ismaster = topology.lastIsMaster() || {};
+    if (this.hasWriteStage) {
+      this.readPreference = ReadPreference.primary;
+    }
 
-  if (!hasOutStage || ismaster.maxWireVersion >= MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT) {
-    decorateWithReadConcern(command, target, options);
-  }
+    if (options.explain && (this.readConcern || this.writeConcern)) {
+      throw new MongoError(
+        '"explain" cannot be used on an aggregate call with readConcern/writeConcern'
+      );
+    }
 
-  if (pipeline.length > 0 && pipeline[pipeline.length - 1]['$out'] && takesWriteConcern) {
-    applyWriteConcern(command, optionSources, options);
+    if (options.cursor != null && typeof options.cursor !== 'object') {
+      throw new MongoError('cursor options must be an object');
+    }
   }
 
-  try {
-    decorateWithCollation(command, target, options);
-  } catch (err) {
-    if (typeof callback === 'function') return callback(err, null);
-    throw err;
+  get canRetryRead() {
+    return !this.hasWriteStage;
   }
 
-  if (options.bypassDocumentValidation === true) {
-    command.bypassDocumentValidation = options.bypassDocumentValidation;
+  addToPipeline(stage) {
+    this.pipeline.push(stage);
   }
 
-  if (typeof options.allowDiskUse === 'boolean') command.allowDiskUse = options.allowDiskUse;
-  if (typeof options.maxTimeMS === 'number') command.maxTimeMS = options.maxTimeMS;
+  execute(server, callback) {
+    const options = this.options;
+    const serverWireVersion = maxWireVersion(server);
+    const command = { aggregate: this.target, pipeline: this.pipeline };
 
-  if (options.hint) command.hint = options.hint;
-
-  options = Object.assign({}, options);
-
-  // Ensure we have the right read preference inheritance
-  options.readPreference = resolveReadPreference(isDbAggregate ? db : coll, options);
-
-  if (options.explain) {
-    if (command.readConcern || command.writeConcern) {
-      throw toError('"explain" cannot be used on an aggregate call with readConcern/writeConcern');
+    if (this.hasWriteStage && serverWireVersion < MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT) {
+      this.readConcern = null;
     }
-    command.explain = options.explain;
-  }
 
-  if (typeof options.comment === 'string') command.comment = options.comment;
+    if (serverWireVersion >= 5) {
+      if (this.hasWriteStage && this.writeConcern) {
+        Object.assign(command, { writeConcern: this.writeConcern });
+      }
+    }
 
-  // Validate that cursor options is valid
-  if (options.cursor != null && typeof options.cursor !== 'object') {
-    throw toError('cursor options must be an object');
-  }
+    if (options.bypassDocumentValidation === true) {
+      command.bypassDocumentValidation = options.bypassDocumentValidation;
+    }
 
-  options.cursor = options.cursor || {};
-  if (options.batchSize && !hasOutStage) options.cursor.batchSize = options.batchSize;
-  command.cursor = options.cursor;
+    if (typeof options.allowDiskUse === 'boolean') {
+      command.allowDiskUse = options.allowDiskUse;
+    }
 
-  // promiseLibrary
-  options.promiseLibrary = target.s.promiseLibrary;
+    if (options.hint) {
+      command.hint = options.hint;
+    }
 
-  // Set the AggregationCursor constructor
-  options.cursorFactory = AggregationCursor;
+    if (options.explain) {
+      options.full = false;
+      command.explain = options.explain;
+    }
 
-  if (typeof callback !== 'function') {
-    if (!topology.capabilities()) {
-      throw new MongoError('cannot connect to server');
+    command.cursor = options.cursor || {};
+    if (options.batchSize && !this.hasWriteStage) {
+      command.cursor.batchSize = options.batchSize;
     }
 
-    return topology.cursor(namespace.toString(), command, options);
+    super.executeCommand(server, command, callback);
   }
-
-  return handleCallback(callback, null, topology.cursor(namespace.toString(), command, options));
 }
 
-module.exports = {
-  aggregate
-};
+defineAspects(AggregateOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXECUTE_WITH_SELECTION
+]);
+
+module.exports = AggregateOperation;

package/lib/operations/close.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const Aspect = require('./operation').Aspect;
+const defineAspects = require('./operation').defineAspects;
+const OperationBase = require('./operation').OperationBase;
+
+class CloseOperation extends OperationBase {
+  constructor(client, force) {
+    super();
+    this.client = client;
+    this.force = force;
+  }
+
+  execute(callback) {
+    const client = this.client;
+    const force = this.force;
+    const completeClose = err => {
+      client.emit('close', client);
+      for (const item of client.s.dbCache) {
+        item[1].emit('close', client);
+      }
+
+      client.removeAllListeners('close');
+      callback(err, null);
+    };
+
+    if (client.topology == null) {
+      completeClose();
+      return;
+    }
+
+    client.topology.close(force, err => {
+      const autoEncrypter = client.topology.s.options.autoEncrypter;
+      if (!autoEncrypter) {
+        completeClose(err);
+        return;
+      }
+
+      autoEncrypter.teardown(force, err2 => completeClose(err || err2));
+    });
+  }
+}
+
+defineAspects(CloseOperation, [Aspect.SKIP_SESSION]);
+
+module.exports = CloseOperation;