mongodb 3.2.5 → 3.3.0-beta2

package/lib/core/wireprotocol/query.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const Query = require('../connection/commands').Query;
+const MongoError = require('../error').MongoError;
+const getReadPreference = require('./shared').getReadPreference;
+const collectionNamespace = require('./shared').collectionNamespace;
+const isSharded = require('./shared').isSharded;
+const maxWireVersion = require('../utils').maxWireVersion;
+const applyCommonQueryOptions = require('./shared').applyCommonQueryOptions;
+const command = require('./command');
+
+function query(server, ns, cmd, cursorState, options, callback) {
+  options = options || {};
+  if (cursorState.cursorId != null) {
+    return callback();
+  }
+
+  if (cmd == null) {
+    return callback(new MongoError(`command ${JSON.stringify(cmd)} does not return a cursor`));
+  }
+
+  if (maxWireVersion(server) < 4) {
+    const query = prepareLegacyFindQuery(server, ns, cmd, cursorState, options);
+    const queryOptions = applyCommonQueryOptions({}, cursorState);
+    if (typeof query.documentsReturnedIn === 'string') {
+      queryOptions.documentsReturnedIn = query.documentsReturnedIn;
+    }
+
+    server.s.pool.write(query, queryOptions, callback);
+    return;
+  }
+
+  const readPreference = getReadPreference(cmd, options);
+  const findCmd = prepareFindCommand(server, ns, cmd, cursorState, options);
+
+  // NOTE: This actually modifies the passed in cmd, and our code _depends_ on this
+  //       side-effect. Change this ASAP
+  cmd.virtual = false;
+
+  const commandOptions = Object.assign(
+    {
+      documentsReturnedIn: 'firstBatch',
+      numberToReturn: 1,
+      slaveOk: readPreference.slaveOk()
+    },
+    options
+  );
+
+  if (cmd.readPreference) commandOptions.readPreference = readPreference;
+  command(server, ns, findCmd, commandOptions, callback);
+}
+
+function prepareFindCommand(server, ns, cmd, cursorState) {
+  cursorState.batchSize = cmd.batchSize || cursorState.batchSize;
+  let findCmd = {
+    find: collectionNamespace(ns)
+  };
+
+  if (cmd.query) {
+    if (cmd.query['$query']) {
+      findCmd.filter = cmd.query['$query'];
+    } else {
+      findCmd.filter = cmd.query;
+    }
+  }
+
+  let sortValue = cmd.sort;
+  if (Array.isArray(sortValue)) {
+    const sortObject = {};
+
+    if (sortValue.length > 0 && !Array.isArray(sortValue[0])) {
+      let sortDirection = sortValue[1];
+      if (sortDirection === 'asc') {
+        sortDirection = 1;
+      } else if (sortDirection === 'desc') {
+        sortDirection = -1;
+      }
+
+      sortObject[sortValue[0]] = sortDirection;
+    } else {
+      for (let i = 0; i < sortValue.length; i++) {
+        let sortDirection = sortValue[i][1];
+        if (sortDirection === 'asc') {
+          sortDirection = 1;
+        } else if (sortDirection === 'desc') {
+          sortDirection = -1;
+        }
+
+        sortObject[sortValue[i][0]] = sortDirection;
+      }
+    }
+
+    sortValue = sortObject;
+  }
+
+  if (cmd.sort) findCmd.sort = sortValue;
+  if (cmd.fields) findCmd.projection = cmd.fields;
+  if (cmd.hint) findCmd.hint = cmd.hint;
+  if (cmd.skip) findCmd.skip = cmd.skip;
+  if (cmd.limit) findCmd.limit = cmd.limit;
+  if (cmd.limit < 0) {
+    findCmd.limit = Math.abs(cmd.limit);
+    findCmd.singleBatch = true;
+  }
+
+  if (typeof cmd.batchSize === 'number') {
+    if (cmd.batchSize < 0) {
+      if (cmd.limit !== 0 && Math.abs(cmd.batchSize) < Math.abs(cmd.limit)) {
+        findCmd.limit = Math.abs(cmd.batchSize);
+      }
+
+      findCmd.singleBatch = true;
+    }
+
+    findCmd.batchSize = Math.abs(cmd.batchSize);
+  }
+
+  if (cmd.comment) findCmd.comment = cmd.comment;
+  if (cmd.maxScan) findCmd.maxScan = cmd.maxScan;
+  if (cmd.maxTimeMS) findCmd.maxTimeMS = cmd.maxTimeMS;
+  if (cmd.min) findCmd.min = cmd.min;
+  if (cmd.max) findCmd.max = cmd.max;
+  findCmd.returnKey = cmd.returnKey ? cmd.returnKey : false;
+  findCmd.showRecordId = cmd.showDiskLoc ? cmd.showDiskLoc : false;
+  if (cmd.snapshot) findCmd.snapshot = cmd.snapshot;
+  if (cmd.tailable) findCmd.tailable = cmd.tailable;
+  if (cmd.oplogReplay) findCmd.oplogReplay = cmd.oplogReplay;
+  if (cmd.noCursorTimeout) findCmd.noCursorTimeout = cmd.noCursorTimeout;
+  if (cmd.awaitData) findCmd.awaitData = cmd.awaitData;
+  if (cmd.awaitdata) findCmd.awaitData = cmd.awaitdata;
+  if (cmd.partial) findCmd.partial = cmd.partial;
+  if (cmd.collation) findCmd.collation = cmd.collation;
+  if (cmd.readConcern) findCmd.readConcern = cmd.readConcern;
+
+  // If we have explain, we need to rewrite the find command
+  // to wrap it in the explain command
+  if (cmd.explain) {
+    findCmd = {
+      explain: findCmd
+    };
+  }
+
+  return findCmd;
+}
+
+function prepareLegacyFindQuery(server, ns, cmd, cursorState, options) {
+  options = options || {};
+  const bson = server.s.bson;
+  const readPreference = getReadPreference(cmd, options);
+  cursorState.batchSize = cmd.batchSize || cursorState.batchSize;
+
+  let numberToReturn = 0;
+  if (
+    cursorState.limit < 0 ||
+    (cursorState.limit !== 0 && cursorState.limit < cursorState.batchSize) ||
+    (cursorState.limit > 0 && cursorState.batchSize === 0)
+  ) {
+    numberToReturn = cursorState.limit;
+  } else {
+    numberToReturn = cursorState.batchSize;
+  }
+
+  const numberToSkip = cursorState.skip || 0;
+
+  const findCmd = {};
+  if (isSharded(server) && readPreference) {
+    findCmd['$readPreference'] = readPreference.toJSON();
+  }
+
+  if (cmd.sort) findCmd['$orderby'] = cmd.sort;
+  if (cmd.hint) findCmd['$hint'] = cmd.hint;
+  if (cmd.snapshot) findCmd['$snapshot'] = cmd.snapshot;
+  if (typeof cmd.returnKey !== 'undefined') findCmd['$returnKey'] = cmd.returnKey;
+  if (cmd.maxScan) findCmd['$maxScan'] = cmd.maxScan;
+  if (cmd.min) findCmd['$min'] = cmd.min;
+  if (cmd.max) findCmd['$max'] = cmd.max;
+  if (typeof cmd.showDiskLoc !== 'undefined') findCmd['$showDiskLoc'] = cmd.showDiskLoc;
+  if (cmd.comment) findCmd['$comment'] = cmd.comment;
+  if (cmd.maxTimeMS) findCmd['$maxTimeMS'] = cmd.maxTimeMS;
+  if (cmd.explain) {
+    // nToReturn must be 0 (match all) or negative (match N and close cursor)
+    // nToReturn > 0 will give explain results equivalent to limit(0)
+    numberToReturn = -Math.abs(cmd.limit || 0);
+    findCmd['$explain'] = true;
+  }
+
+  findCmd['$query'] = cmd.query;
+  if (cmd.readConcern && cmd.readConcern.level !== 'local') {
+    throw new MongoError(
+      `server find command does not support a readConcern level of ${cmd.readConcern.level}`
+    );
+  }
+
+  if (cmd.readConcern) {
+    cmd = Object.assign({}, cmd);
+    delete cmd['readConcern'];
+  }
+
+  const serializeFunctions =
+    typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
+  const ignoreUndefined =
+    typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : false;
+
+  const query = new Query(bson, ns, findCmd, {
+    numberToSkip: numberToSkip,
+    numberToReturn: numberToReturn,
+    pre32Limit: typeof cmd.limit !== 'undefined' ? cmd.limit : undefined,
+    checkKeys: false,
+    returnFieldSelector: cmd.fields,
+    serializeFunctions: serializeFunctions,
+    ignoreUndefined: ignoreUndefined
+  });
+
+  if (typeof cmd.tailable === 'boolean') query.tailable = cmd.tailable;
+  if (typeof cmd.oplogReplay === 'boolean') query.oplogReplay = cmd.oplogReplay;
+  if (typeof cmd.noCursorTimeout === 'boolean') query.noCursorTimeout = cmd.noCursorTimeout;
+  if (typeof cmd.awaitData === 'boolean') query.awaitData = cmd.awaitData;
+  if (typeof cmd.partial === 'boolean') query.partial = cmd.partial;
+
+  query.slaveOk = readPreference.slaveOk();
+  return query;
+}
+
+module.exports = query;

package/lib/core/wireprotocol/shared.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const ReadPreference = require('../topologies/read_preference');
+const MongoError = require('../error').MongoError;
+const ServerType = require('../sdam/server_description').ServerType;
+const TopologyDescription = require('../sdam/topology_description').TopologyDescription;
+
+const MESSAGE_HEADER_SIZE = 16;
+const COMPRESSION_DETAILS_SIZE = 9; // originalOpcode + uncompressedSize, compressorID
+
+// OPCODE Numbers
+// Defined at https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#request-opcodes
+var opcodes = {
+  OP_REPLY: 1,
+  OP_UPDATE: 2001,
+  OP_INSERT: 2002,
+  OP_QUERY: 2004,
+  OP_GETMORE: 2005,
+  OP_DELETE: 2006,
+  OP_KILL_CURSORS: 2007,
+  OP_COMPRESSED: 2012,
+  OP_MSG: 2013
+};
+
+var getReadPreference = function(cmd, options) {
+  // Default to command version of the readPreference
+  var readPreference = cmd.readPreference || new ReadPreference('primary');
+  // If we have an option readPreference override the command one
+  if (options.readPreference) {
+    readPreference = options.readPreference;
+  }
+
+  if (typeof readPreference === 'string') {
+    readPreference = new ReadPreference(readPreference);
+  }
+
+  if (!(readPreference instanceof ReadPreference)) {
+    throw new MongoError('read preference must be a ReadPreference instance');
+  }
+
+  return readPreference;
+};
+
+// Parses the header of a wire protocol message
+var parseHeader = function(message) {
+  return {
+    length: message.readInt32LE(0),
+    requestId: message.readInt32LE(4),
+    responseTo: message.readInt32LE(8),
+    opCode: message.readInt32LE(12)
+  };
+};
+
+function applyCommonQueryOptions(queryOptions, options) {
+  Object.assign(queryOptions, {
+    raw: typeof options.raw === 'boolean' ? options.raw : false,
+    promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,
+    promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
+    promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
+    monitoring: typeof options.monitoring === 'boolean' ? options.monitoring : false,
+    fullResult: typeof options.fullResult === 'boolean' ? options.fullResult : false
+  });
+
+  if (typeof options.socketTimeout === 'number') {
+    queryOptions.socketTimeout = options.socketTimeout;
+  }
+
+  if (options.session) {
+    queryOptions.session = options.session;
+  }
+
+  if (typeof options.documentsReturnedIn === 'string') {
+    queryOptions.documentsReturnedIn = options.documentsReturnedIn;
+  }
+
+  return queryOptions;
+}
+
+function isSharded(topologyOrServer) {
+  if (topologyOrServer.type === 'mongos') return true;
+  if (topologyOrServer.description && topologyOrServer.description.type === ServerType.Mongos) {
+    return true;
+  }
+
+  // NOTE: This is incredibly inefficient, and should be removed once command construction
+  //       happens based on `Server` not `Topology`.
+  if (topologyOrServer.description && topologyOrServer.description instanceof TopologyDescription) {
+    const servers = Array.from(topologyOrServer.description.servers.values());
+    return servers.some(server => server.type === ServerType.Mongos);
+  }
+
+  return false;
+}
+
+function databaseNamespace(ns) {
+  return ns.split('.')[0];
+}
+function collectionNamespace(ns) {
+  return ns
+    .split('.')
+    .slice(1)
+    .join('.');
+}
+
+module.exports = {
+  getReadPreference,
+  MESSAGE_HEADER_SIZE,
+  COMPRESSION_DETAILS_SIZE,
+  opcodes,
+  parseHeader,
+  applyCommonQueryOptions,
+  isSharded,
+  databaseNamespace,
+  collectionNamespace
+};

package/lib/core/wireprotocol/write_command.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const MongoError = require('../error').MongoError;
+const collectionNamespace = require('./shared').collectionNamespace;
+const command = require('./command');
+
+function writeCommand(server, type, opsField, ns, ops, options, callback) {
+  if (ops.length === 0) throw new MongoError(`${type} must contain at least one document`);
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  options = options || {};
+  const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
+  const writeConcern = options.writeConcern;
+
+  const writeCommand = {};
+  writeCommand[type] = collectionNamespace(ns);
+  writeCommand[opsField] = ops;
+  writeCommand.ordered = ordered;
+
+  if (writeConcern && Object.keys(writeConcern).length > 0) {
+    writeCommand.writeConcern = writeConcern;
+  }
+
+  if (options.collation) {
+    for (let i = 0; i < writeCommand[opsField].length; i++) {
+      if (!writeCommand[opsField][i].collation) {
+        writeCommand[opsField][i].collation = options.collation;
+      }
+    }
+  }
+
+  if (options.bypassDocumentValidation === true) {
+    writeCommand.bypassDocumentValidation = options.bypassDocumentValidation;
+  }
+
+  const commandOptions = Object.assign(
+    {
+      checkKeys: type === 'insert',
+      numberToReturn: 1
+    },
+    options
+  );
+
+  command(server, ns, writeCommand, commandOptions, callback);
+}
+
+module.exports = writeCommand;

package/lib/cursor.js

@@ -6,18 +6,22 @@ const inherits = require('util').inherits;
 const deprecate = require('util').deprecate;
 const handleCallback = require('./utils').handleCallback;
 const SUPPORTS = require('./utils').SUPPORTS;
-const ReadPreference = require('mongodb-core').ReadPreference;
-const MongoError = require('mongodb-core').MongoError;
+const MongoDBNamespace = require('./utils').MongoDBNamespace;
+const ReadPreference = require('./core').ReadPreference;
+const MongoError = require('./core').MongoError;
 const Readable = require('stream').Readable;
-const CoreCursor = require('mongodb-core').Cursor;
-const Map = require('mongodb-core').BSON.Map;
-const executeOperation = require('./utils').executeOperation;
+const CoreCursor = require('./core').Cursor;
+const Map = require('./core').BSON.Map;
 
-const count = require('./operations/cursor_ops').count;
 const each = require('./operations/cursor_ops').each;
-const hasNext = require('./operations/cursor_ops').hasNext;
-const next = require('./operations/cursor_ops').next;
-const toArray = require('./operations/cursor_ops').toArray;
+
+const CountOperation = require('./operations/count');
+const ExplainOperation = require('./operations/explain');
+const HasNextOperation = require('./operations/has_next');
+const NextOperation = require('./operations/next');
+const ToArrayOperation = require('./operations/to_array');
+
+const executeOperation = require('./operations/execute_operation');
 
 /**
  * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
@@ -53,7 +57,7 @@ const toArray = require('./operations/cursor_ops').toArray;
  */
 
 /**
- * Namespace provided by the mongodb-core and node.js
+ * Namespace provided by the code module
  * @external CoreCursor
  * @external Readable
  */
@@ -102,10 +106,12 @@ const fields = ['numberOfRetries', 'tailableRetryInterval'];
  *
  * collection.find({}).maxTimeMS(1000).maxScan(100).skip(1).toArray(..)
  */
-function Cursor(bson, ns, cmd, options, topology, topologyOptions) {
+function Cursor(topology, ns, cmd, options) {
   CoreCursor.apply(this, Array.prototype.slice.call(arguments, 0));
   const state = Cursor.INIT;
   const streamOptions = {};
+  const bson = topology.s.bson;
+  const topologyOptions = topology.s.options;
 
   // Tailable cursor options
   const numberOfRetries = options.numberOfRetries || 5;
@@ -131,7 +137,7 @@ function Cursor(bson, ns, cmd, options, topology, topologyOptions) {
     // BSON
     bson: bson,
     // Namespace
-    ns: ns,
+    namespace: MongoDBNamespace.fromString(ns),
     // Command
     cmd: cmd,
     // Options
@@ -210,9 +216,6 @@ if (SUPPORTS.ASYNC_ITERATOR) {
 
 // Map core cursor _next method so we can apply mapping
 Cursor.prototype._next = function() {
-  if (this._initImplicitSession) {
-    this._initImplicitSession();
-  }
   return CoreCursor.prototype.next.apply(this, arguments);
 };
 
@@ -220,11 +223,14 @@ for (let name in CoreCursor.prototype) {
   Cursor.prototype[name] = CoreCursor.prototype[name];
 }
 
-Cursor.prototype._initImplicitSession = function() {
+Cursor.prototype._initializeCursor = function(callback) {
+  // implicitly create a session if one has not been provided
   if (!this.s.explicitlyIgnoreSession && !this.s.session && this.s.topology.hasSessionSupport()) {
     this.s.session = this.s.topology.startSession({ owner: this });
     this.cursorState.session = this.s.session;
   }
+
+  CoreCursor.prototype._initializeCursor.apply(this, [callback]);
 };
 
 Cursor.prototype._endSession = function() {
@@ -242,9 +248,9 @@ Cursor.prototype._endSession = function() {
  * @return {Promise} returns Promise if no callback passed
  */
 Cursor.prototype.hasNext = function(callback) {
-  return executeOperation(this.s.topology, hasNext, [this, callback], {
-    skipSessions: true
-  });
+  const hasNextOperation = new HasNextOperation(this);
+
+  return executeOperation(this.s.topology, hasNextOperation, callback);
 };
 
 /**
@@ -255,9 +261,9 @@ Cursor.prototype.hasNext = function(callback) {
  * @return {Promise} returns Promise if no callback passed
  */
 Cursor.prototype.next = function(callback) {
-  return executeOperation(this.s.topology, next, [this, callback], {
-    skipSessions: true
-  });
+  const nextOperation = new NextOperation(this);
+
+  return executeOperation(this.s.topology, nextOperation, callback);
 };
 
 /**
@@ -826,9 +832,9 @@ Cursor.prototype.toArray = function(callback) {
     });
   }
 
-  return executeOperation(this.s.topology, toArray, [this, callback], {
-    skipSessions: true
-  });
+  const toArrayOperation = new ToArrayOperation(this);
+
+  return executeOperation(this.s.topology, toArrayOperation, callback);
 };
 
 /**
@@ -866,9 +872,9 @@ Cursor.prototype.count = function(applySkipLimit, opts, callback) {
     opts = Object.assign({}, opts, { session: this.s.session });
   }
 
-  return executeOperation(this.s.topology, count, [this, applySkipLimit, opts, callback], {
-    skipSessions: !!this.s.session
-  });
+  const countOperation = new CountOperation(this, applySkipLimit, opts);
+
+  return executeOperation(this.s.topology, countOperation, callback);
 };
 
 /**
@@ -1001,9 +1007,9 @@ Cursor.prototype.explain = function(callback) {
     delete this.s.cmd['readConcern'];
   }
 
-  return executeOperation(this.s.topology, this._next.bind(this), [callback], {
-    skipSessions: true
-  });
+  const explainOperation = new ExplainOperation(this);
+
+  return executeOperation(this.s.topology, explainOperation, callback);
 };
 
 Cursor.prototype._read = function() {
@@ -1074,23 +1080,11 @@ Object.defineProperty(Cursor.prototype, 'readPreference', {
 Object.defineProperty(Cursor.prototype, 'namespace', {
   enumerable: true,
   get: function() {
-    if (!this || !this.s) {
-      return null;
+    if (!(this && this.s)) {
+      return;
     }
 
-    // TODO: refactor this logic into core
-    const ns = this.s.ns || '';
-    const firstDot = ns.indexOf('.');
-    if (firstDot < 0) {
-      return {
-        database: this.s.ns,
-        collection: ''
-      };
-    }
-    return {
-      database: ns.substr(0, firstDot),
-      collection: ns.substr(firstDot + 1)
-    };
+    return this.s.namespace.toString();
   }
 });